wangxx1809/GrpcPrint
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
GrpcPrint/PrintS/job/MetaData.h

567 lines
14 KiB
C
Raw Normal View History

添加功能
2024-03-26 10:33:00 +08:00
#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;
}
};
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;
DataBlock() {
order = 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 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 &parameterMap; }
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);
void AddErrorInfo(string str);
//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);
map<DataBlock*, int>* GetDBRefScanLaser() { return &m_DBRefScanLaser; }
ScannerControlCfg* GetLaserCfgByPart(Part* part);
void UpdatePartRefScanLaser(Part* part, int cno);
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();
}
}
public:
map<DataBlock*, BPBinary::BinDataBlock*> m_FirstLayerBlockMap;
bool m_IsScanOrderSeqV2;
static map<string, int> m_DataTypeMap;
protected:
void ClearBlockMap();
void ClearPrevBlockMap();
void ClearRemoteBlockMap();
void ClearBFileMap();
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策略
//map<int, ScannerControlCfg*> m_PartRefScanLaser; //Part策略
map<DataBlock*, int> m_DBRefScanLaser;
//map<int, double> m_EvaTimeMap;
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);
Reference in New Issue Copy Permalink