GrpcPrint/PrintS/job/H3DMetaData.cpp

#include "H3DMetaData.h"

H3DMetaData::H3DMetaData()
{}

H3DMetaData::~H3DMetaData()
{}

void H3DMetaData::AddHJobFile2Map(string name, ifstream* ifs,ifstream* pfs)
{
	for (map<string, ifstream*>::iterator it = m_binary_file_map.begin(); it != m_binary_file_map.end(); ++it)
	{
		ifstream* pbfile = it->second;
		if (pbfile) {
			pbfile->close();
			delete pbfile;
		}
	}
	m_binary_file_map.clear();
	m_binary_file_map[name] = ifs;

	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();
	m_pre_file_map[name] = pfs;
}

bool H3DMetaData::ReadBDataBlock(JobDimensions* summary, Dimensions* partLayerDimensions,BPBinary::BinDataBlock* datablock, ifstream* ifs)
{
	bool rel = true;
	float xmax = summary->xmax + 10.0f;
	float xmin = summary->xmin - 10.0f;
	float ymax = summary->ymax + 10.0f;
	float ymin = summary->ymin - 10.0f;

	ifs->read((char*)&datablock->type, sizeof(datablock->type));
	if (datablock->type == BIN_VECTOR) {
		unsigned int vectorSize = 0;
		ifs->read((char*)&vectorSize, sizeof(vectorSize));
		for (size_t pointIndex = 0; pointIndex < vectorSize; ++pointIndex) {
			BPBinary::VectorPoint* pvp = new BPBinary::VectorPoint();
			ifs->read((char*)pvp, sizeof(BPBinary::VectorPoint));
			if (pvp->x1 < partLayerDimensions->xmin)partLayerDimensions->xmin = pvp->x1;
			if (pvp->x2 < partLayerDimensions->xmin)partLayerDimensions->xmin = pvp->x2;
			if (pvp->x1 > partLayerDimensions->xmax)partLayerDimensions->xmax = pvp->x1;
			if (pvp->x2 > partLayerDimensions->xmax)partLayerDimensions->xmax = pvp->x2;
			if (pvp->y1 < partLayerDimensions->ymin)partLayerDimensions->ymin = pvp->y1;
			if (pvp->y2 < partLayerDimensions->ymin)partLayerDimensions->ymin = pvp->y2;
			if (pvp->y1 > partLayerDimensions->ymax)partLayerDimensions->ymax = pvp->y1;
			if (pvp->y2 > partLayerDimensions->ymax)partLayerDimensions->ymax = pvp->y2;
			if (m_ExtCfg->m_CheckDataWhenInport) {
				if (((pvp->x1 > xmax) || (pvp->x1 < xmin)) ||
					((pvp->x2 > xmax) || (pvp->x2 < xmin)) ||
					((pvp->y1 > ymax) || (pvp->y1 < ymin)) ||
					((pvp->y2 > ymax) || (pvp->y2 < ymin))) {
					rel = false;
					delete pvp;
					break;
				}
			}
			datablock->point_indexs.push_back(pvp);
		}
	}
	else if (datablock->type == BIN_CHAIN) {
		unsigned int chainSize = 0;
		ifs->read((char*)&chainSize, sizeof(chainSize));

		for (size_t chainIndex = 0; chainIndex < chainSize; ++chainIndex) {
			BPBinary::ChainPoint* point = new BPBinary::ChainPoint();
			unsigned int pointSize = 0;
			ifs->read((char*)&pointSize, sizeof(pointSize));
			point->num_of_point = pointSize;
			datablock->point_indexs.push_back(point);
			bool hasError = false;
			for (unsigned int chainPointIndex = 0; chainPointIndex < pointSize; ++chainPointIndex) {
				BPBinary::BPoint* bpoint = new BPBinary::BPoint();
				ifs->read((char*)bpoint, sizeof(BPBinary::BPoint));
				if (bpoint->x < partLayerDimensions->xmin)partLayerDimensions->xmin = bpoint->x;
				if (bpoint->x > partLayerDimensions->xmax)partLayerDimensions->xmax = bpoint->x;
				if (bpoint->y < partLayerDimensions->ymin)partLayerDimensions->ymin = bpoint->y;
				if (bpoint->y > partLayerDimensions->ymax)partLayerDimensions->ymax = bpoint->y;

				if (m_ExtCfg->m_CheckDataWhenInport) {
					if (((bpoint->x > xmax) || (bpoint->x < xmin)) ||
						((bpoint->y > ymax) || (bpoint->y < ymin))) {
						rel = false;
						hasError = true;
						delete bpoint;
						break;
					}
				}
				point->points.push_back(bpoint);
			}
			if (hasError)break;
		}
	}
	else {
		rel = false;
	}
	return rel;
}

bool H3DMetaData::LoadLayerByIndex(unsigned int lindex)
{
	bool rel = true;
	if (lindex >= layers->vector_layers.size())return false;
	LockMainDB();
	Layer* layer = layers->vector_layers[lindex];
	ClearBlockMap();
	vector<DataBlock*> datablocks = layer->data_blocks;
	for (size_t i = 0; i < datablocks.size(); ++i) {
		DataBlock* db = datablocks[i];
		BinaryFile* pbf = binary_files[db->bin->file_id];
		if (!pbf)break;
		ifstream* ifs = m_binary_file_map[pbf->name];
		if (!ifs)break;
		if (!db->belongPart)continue;
		BPBinary::BinDataBlock* pbindb = new BPBinary::BinDataBlock;
		ifs->seekg(db->bin->pos, ios::beg);
		if (!ReadBDataBlock(general_info->job_dimensions, db->belongPart->layerDimensions, pbindb, ifs)) {
			delete pbindb;
			rel = false;
			break;
		}
		m_block_map[db] = pbindb;
	}
	m_currentLayer = layer;
	UnLockMainDB();
	return rel;
}

//lindex是第几层
bool H3DMetaData::GetLayerByIndex(unsigned int lindex, ::stream::LayerData** response)
{
	bool rel = true;
	if (lindex >= layers->vector_layers.size())return false;
	LockMainDB();
	Layer* layer = layers->vector_layers[lindex];
	ClearBlockMap();
	vector<DataBlock*> datablocks = layer->data_blocks;
	for (size_t i = 0; i < datablocks.size(); ++i) {
		DataBlock* db = datablocks[i];
		BinaryFile* pbf = binary_files[db->bin->file_id];
		if (!pbf)break;
		ifstream* ifs = m_binary_file_map[pbf->name];
		if (!ifs)break;
		if (!db->belongPart)continue;
		BPBinary::BinDataBlock* pbindb = new BPBinary::BinDataBlock;
		ifs->seekg(db->bin->pos, ios::beg);
		if (!ReadBDataBlock(general_info->job_dimensions, db->belongPart->layerDimensions, pbindb, ifs)) {
			delete pbindb;
			rel = false;
			break;
		}
		m_block_map[db] = pbindb;

		stream::LayerDataBlock* p = (*response)->add_layerdatablock();
		p->set_order(datablocks[i]->order);
		p->set_blocktype(m_block_map[datablocks[i]]->type);
		size_t count = m_block_map[datablocks[i]]->point_indexs.size();

		for (size_t i = 0; i < count; ++i) {
			if (p->blocktype() == BIN_VECTOR) {
				stream::VectorDataBlock* pvec = p->add_vecblocks();
				BPBinary::VectorPoint* vecp = (BPBinary::VectorPoint*)(m_block_map[datablocks[i]]->point_indexs[i]);
				pvec->set_startx(vecp->x1);
				pvec->set_endx(vecp->y1);
				pvec->set_starty(vecp->x2);
				pvec->set_endx(vecp->y2);
			}
			else if (p->blocktype() == BIN_CHAIN) {
				stream::ChainDataBlock* pChain = p->add_chainblocks();
				BPBinary::ChainPoint* chainp = (BPBinary::ChainPoint*)(m_block_map[datablocks[i]]->point_indexs[i]);

				pChain->set_dotnum(chainp->num_of_point);
				for (unsigned int chainPointIndex = 0; chainPointIndex < chainp->num_of_point; ++chainPointIndex) {
					stream::Point* pointp = pChain->add_pointvec();
					BPBinary::BPoint* btemppoint = chainp->points[chainPointIndex];
					pointp->set_xpos(btemppoint->x);
					pointp->set_ypos(btemppoint->y);
				}
			}
		}
	}
	(*response)->set_result(rel);

	m_currentLayer = layer;
	UnLockMainDB();
	return rel;
}

bool H3DMetaData::LoadLayer(Layer* layer)
{
	if (layer == NULL) return false;
	LockMainDB();
	ClearBlockMap();
	vector<DataBlock*> datablocks = layer->data_blocks;
	for (size_t i = 0; i < datablocks.size(); ++i) {
		DataBlock* db = datablocks[i];
		BinaryFile* pbf = binary_files[db->bin->file_id];
		if (!pbf)break;
		ifstream* ifs = m_binary_file_map[pbf->name];
		if (!ifs)break;
		if (!db->belongPart)continue;
		BPBinary::BinDataBlock* pbindb = new BPBinary::BinDataBlock;
		ifs->seekg(db->bin->pos, ios::beg);
		ReadBDataBlock(general_info->job_dimensions, db->belongPart->layerDimensions,pbindb, ifs);
		m_block_map[db] = pbindb;
	}
	m_currentLayer = layer;
	UnLockMainDB();
	return true;
}

bool H3DMetaData::LoadFirstLayer()
{
	bool rel = true;
	if (layers->vector_layers.empty())return false;
	Layer* layer = layers->vector_layers[0];
	for (map<DataBlock*, BPBinary::BinDataBlock*>::iterator it = m_FirstLayerBlockMap.begin(); it != m_FirstLayerBlockMap.end(); ++it) {
		delete it->second;
	}
	m_FirstLayerBlockMap.clear();
	vector<DataBlock*> datablocks = layer->data_blocks;
	for (size_t i = 0; i < datablocks.size(); ++i) {
		DataBlock* db = datablocks[i];
		BinaryFile* pbf = binary_files[db->bin->file_id];
		if (!pbf)break;
		ifstream* ifs = m_binary_file_map[pbf->name];
		if (!ifs)break;
		if (!db->belongPart)continue;
		BPBinary::BinDataBlock* pbindb = new BPBinary::BinDataBlock;
		ifs->seekg(db->bin->pos, ios::beg);

		if (!ReadBDataBlock(general_info->job_dimensions, db->belongPart->layerDimensions, pbindb, ifs)) {
			delete pbindb;
			rel = false;
			break;
		}
		m_FirstLayerBlockMap[db] = pbindb;
	}
	return rel;
}

bool H3DMetaData::LoadPrevLayer(Layer* layer)
{
	if (layer == NULL) return false;
	ClearPrevBlockMap();
	vector<DataBlock*> datablocks = layer->data_blocks;
	for (size_t i = 0; i < datablocks.size(); ++i) {
		DataBlock* db = datablocks[i];
		BinaryFile* pbf = binary_files[db->bin->file_id];
		if (!pbf)break;
		ifstream* ifs = m_pre_file_map[pbf->name];
		if (!ifs)break;
		if (!db->belongPart)continue;
		BPBinary::BinDataBlock* pbindb = new BPBinary::BinDataBlock;
		ifs->seekg(db->bin->pos, ios::beg);
		ReadBDataBlock(general_info->job_dimensions, db->belongPart->layerDimensions,pbindb, ifs);
		m_prev_block_map[db] = pbindb;
	}
	m_previewLayer = layer;
	return true;
}

bool H3DMetaData::LoadPrevLayerByIndex(unsigned int lindex)
{
	if (lindex >= layers->vector_layers.size())return false;
	Layer* layer = layers->vector_layers[lindex];
	ClearPrevBlockMap();
	vector<DataBlock*> datablocks = layer->data_blocks;
	for (size_t i = 0; i < datablocks.size(); ++i) {
		DataBlock* db = datablocks[i];
		BinaryFile* pbf = binary_files[db->bin->file_id];
		if (!pbf)break;
		ifstream* ifs = m_pre_file_map[pbf->name];
		if (!ifs)break;
		if (!db->belongPart)continue;
		BPBinary::BinDataBlock* pbindb = new BPBinary::BinDataBlock;
		ifs->seekg(db->bin->pos, ios::beg);
		ReadBDataBlock(general_info->job_dimensions, db->belongPart->layerDimensions,pbindb, ifs);
		m_prev_block_map[db] = pbindb;
	}
	m_previewLayer = layer;
	return true;
}

bool H3DMetaData::LoadRemoteLayerByIndex(unsigned int lindex)
{
	if (lindex >= layers->vector_layers.size())return false;
	Layer* layer = layers->vector_layers[lindex];
	ClearRemoteBlockMap();
	vector<DataBlock*> datablocks = layer->data_blocks;
	for (size_t i = 0; i < datablocks.size(); ++i) {
		DataBlock* db = datablocks[i];
		BinaryFile* pbf = binary_files[db->bin->file_id];
		if (!pbf)break;
		ifstream* ifs = m_pre_file_map[pbf->name];
		if (!ifs)break;
		if (!db->belongPart)continue;
		BPBinary::BinDataBlock* pbindb = new BPBinary::BinDataBlock;
		ifs->seekg(db->bin->pos, ios::beg);
		ReadBDataBlock(general_info->job_dimensions, db->belongPart->layerDimensions,pbindb, ifs);
		m_remote_block_map[db] = pbindb;
	}
	m_RemoteLayer = layer;
	return true;
}