wangxx1809/GrpcPrint
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
GrpcPrint/PrintS/Remote/RemoteClient.cpp

1010 lines
36 KiB
C++
Raw Blame History

#include "RemoteClient.h"
#include <atlbase.h>
#include "../global.h"
#include "../ScannerCtrl/BaseCtrl.h"
#include <bitset>
#include "proto_msg.h"
#include "../camera/GalaxyCamera.h"
#include "../SystemInfo.h"
#include "../Logger.h"
#include "../utils/TimeHelper.h"
#include "../utils/StringHelper.h"
//#include <rapidjson/document.h>
#include "../utils/MathHelper.h"
RemoteClient::RemoteClient(JobController* jobController, ScannerCtrl* sc)
:m_RemoteThread(INVALID_HANDLE_VALUE)
,m_WriteThread(INVALID_HANDLE_VALUE)
, m_ReadThread(INVALID_HANDLE_VALUE)
, m_RunFlag(false)
, m_WriteFlag(false)
,m_ReadFlag(false)
,m_IsLogin(false)
,m_Config(nullptr)
,m_JobController(jobController)
,m_ScannerCtrl(sc)
, m_Camera(NULL)
{
InitializeCriticalSection(&m_MessageCS);
}
RemoteClient::~RemoteClient()
{
StopRemote();
DeleteCriticalSection(&m_MessageCS);
}
void RemoteClient::Init()
{
map<string, CommunicationCfg*>* cfgs = ConfigManager::GetInstance()->GetCommunicationCfg();
if (cfgs->find("REMOTE") != cfgs->end()) {
m_Config=(*cfgs)["REMOTE"];
}
m_MachineCfg = ConfigManager::GetInstance()->GetMachineCfg();
m_RunCfg = ConfigManager::GetInstance()->GetRunCfg();
m_ExtCfg = ConfigManager::GetInstance()->GetExtCfg();
m_HandleMap[PrinterMsg::STATE_REQUEST] = &RemoteClient::HandleStateRequest;
m_HandleMap[PrinterMsg::JOB_INFO_REQUEST] = &RemoteClient::HandleJobInfoRequest;
m_HandleMap[PrinterMsg::CTRL_SYSTEM_PAUSE] = &RemoteClient::HandleCtrlSystemPause;
m_HandleMap[PrinterMsg::CRTL_SYSTEM_STOP] = &RemoteClient::HandleCtrlSystemStop;
m_HandleMap[PrinterMsg::LAYER_DATA_REQUEST] = &RemoteClient::HandleLayerDataRequest;
m_HandleMap[PrinterMsg::CAMERA_DATA_REQUEST] = &RemoteClient::HandleCameraDataRequest;
m_HandleMap[PrinterMsg::ALARM_NOTIFY_RESPONSE] = &RemoteClient::HandleAlarmNotifyResponse;
m_HandleMap[PrinterMsg::STATE_CHANGE_RESPONSE] = &RemoteClient::HandleStateChangeResponse;
m_HandleMap[PrinterMsg::LOG_REQUEST_RECORD_TASK] = &RemoteClient::HandleRecordTasksMsg;
m_HandleMap[PrinterMsg::LOG_REQUEST_RECORD_TASK_LIST] = &RemoteClient::HandleRecordTasksListMsg;
m_HandleMap[PrinterMsg::VERSION_REQUEST] = &RemoteClient::HandleVersionResMsg;
//m_HandleMap[PrinterMsg::REMOTE_JOB_LIST_RESPONSE] = &RemoteClient::HandleRemoteJobResMsg;
ConfigManager::GetInstance()->AddComRefCfg(m_Config, this);
}
void RemoteClient::StartRemote()
{
StopRemote();
m_RunFlag = true;
m_RemoteThread = AtlCreateThread(RemoteProc, this);
}
void RemoteClient::StopRemote()
{
m_RunFlag = false;
StopWrite();
StopRead();
if (m_Client.IsOpen()) {
m_Client.Close();
}
if (m_RemoteThread !=INVALID_HANDLE_VALUE) {
if (WaitForSingleObject(m_RemoteThread, 500) == WAIT_TIMEOUT) {
TerminateThread(m_RemoteThread, 1);
}
CloseHandle(m_RemoteThread);
m_RemoteThread = INVALID_HANDLE_VALUE;
}
m_IsLogin = false;
}
DWORD WINAPI RemoteClient::RemoteProc(RemoteClient* _this)
{
if (_this) {
_this->RemoteRun();
}
return 0;
}
void RemoteClient::RemoteRun()
{
while (m_RunFlag) {
if (!m_Client.IsOpen()) {
if (!m_Client.ConnectTo(m_Config->m_IP.c_str(), m_Config->m_Port, AF_INET, SOCK_STREAM,2000)) {
int count = 0;
while (m_RunFlag && count<30) {
count++;
Sleep(100);
}
continue;
}
}
if (!CheckLogin())continue;
StartWrite();
StartRead();
WaitForSingleObject(m_ReadThread, INFINITE);
m_WriteFlag = false;
WaitForSingleObject(m_WriteThread, INFINITE);
m_Client.Close();
m_IsLogin = false;
}
}
void RemoteClient::StartWrite()
{
StopWrite();
m_WriteFlag = true;
m_WriteThread = AtlCreateThread(WriteProc, this);
}
void RemoteClient::StopWrite()
{
m_WriteFlag = false;
if (m_WriteThread != INVALID_HANDLE_VALUE) {
if (WaitForSingleObject(m_WriteThread, 500) == WAIT_TIMEOUT) {
TerminateThread(m_WriteThread, 1);
}
CloseHandle(m_WriteThread);
m_WriteThread = INVALID_HANDLE_VALUE;
}
EnterCriticalSection(&m_MessageCS);
while (!m_MessageQueue.empty()) {
PrinterMsg::HMessage* message=m_MessageQueue.front();
delete message;
message = nullptr;
m_MessageQueue.pop();
}
LeaveCriticalSection(&m_MessageCS);
}
DWORD WINAPI RemoteClient::WriteProc(RemoteClient* _this)
{
if (_this) {
_this->WriteRun();
}
return 0;
}
void RemoteClient::WriteRun()
{
while (m_RunFlag && m_WriteFlag ) {
PrinterMsg::HMessage* message = nullptr;
EnterCriticalSection(&m_MessageCS);
if (!m_MessageQueue.empty())
{
message = m_MessageQueue.front();
m_MessageQueue.pop();
}
LeaveCriticalSection(&m_MessageCS);
if (message != nullptr)
{
size_t msgSize;
unsigned char* buf = ProtoMsgCodec::encode(message, msgSize);
if (buf != nullptr && msgSize > 0) {
int scount=m_Client.Write(buf, msgSize, 0, 500);
delete[] buf;
delete message;
message = nullptr;
if (scount ==-1) {
m_WriteFlag = false;
m_Client.Close();
m_IsLogin = false;
break;
}
}
}
Sleep(50);
}
}
void RemoteClient::StartRead()
{
StopRead();
m_ReadFlag = true;
m_ReadThread = AtlCreateThread(ReadProc, this);
}
void RemoteClient::StopRead()
{
m_ReadFlag = false;
if (m_ReadThread != INVALID_HANDLE_VALUE) {
if (WaitForSingleObject(m_ReadThread, 500) == WAIT_TIMEOUT) {
TerminateThread(m_ReadThread, 1);
}
CloseHandle(m_ReadThread);
m_ReadThread = INVALID_HANDLE_VALUE;
}
}
DWORD WINAPI RemoteClient::ReadProc(RemoteClient* _this)
{
if (_this) {
_this->ReadRun();
}
return 0;
}
void RemoteClient::ReadRun()
{
unsigned char recvBuffer[2048];
int retry = 0;
while (m_RunFlag&& m_ReadFlag) {
int rcount=m_Client.Read(recvBuffer, sizeof(recvBuffer), 0, 3000);
if (rcount == -1) {
m_ReadFlag = false;
m_Client.Close();
m_IsLogin = false;
break;
}
else if (rcount == 0) {
if (++retry > 30) {
m_ReadFlag = false;
m_Client.Close();
m_IsLogin = false;
break;
}
continue;
}
retry = 0;
ProtoMessage* tmp_msg = ProtoMsgCodec::decode(recvBuffer, rcount);
if (tmp_msg == nullptr) {
continue;
}
PrinterMsg::HMessage* msg = dynamic_cast<PrinterMsg::HMessage*>(tmp_msg);
PrinterMsg::MSG mtype=msg->type();
if (m_HandleMap.find(mtype) != m_HandleMap.end()) {
m_HandleMap[mtype](this,msg);
}
delete msg;
}
}
bool RemoteClient::CheckLogin()
{
if (m_IsLogin)return true;
if (!m_Client.IsOpen())return false;
PrinterMsg::HMessage message;
MachineMsg* machineMsg=message.mutable_request()->mutable_machinemsg();
machineMsg->set_machineid(m_MachineCfg->m_serial);
machineMsg->set_machinetype(MachineMsg_MachineType(m_MachineCfg->m_MachineType));
machineMsg->set_purifiertype(MachineMsg_PurifierType(m_MachineCfg->m_PulifierType));
machineMsg->set_laststarttime(m_MachineCfg->m_lastStartTime);
machineMsg->set_lastshutdowntime(m_MachineCfg->m_lastShutdownTime);
//machineMsg->set_language(m_MachineCfg->m_language);
machineMsg->set_language(0);
machineMsg->set_password(m_MachineCfg->m_ConnectPassword);
machineMsg->set_name(m_MachineCfg->m_Name);
machineMsg->set_location(m_MachineCfg->m_Location);
message.set_type(PrinterMsg::LOGIN_REQUEST);
message.set_mcode(m_MachineCfg->m_MachineCode);
// unsigned char sendBuffer[2048];
unsigned char rendBuffer[1024];
size_t msgSize;
unsigned char* buf = ProtoMsgCodec::encode(&message, msgSize);
if (buf != nullptr && msgSize > 0)
{
int scount=m_Client.Write(buf, msgSize, 0, 3000);
if (scount == msgSize) {
int rcount=m_Client.Read(rendBuffer, sizeof(rendBuffer), 0, 5000);
if (rcount > 0) {
ProtoMessage* tmp_msg = ProtoMsgCodec::decode(rendBuffer, rcount);
if (tmp_msg) {
PrinterMsg::HMessage* loginResp = dynamic_cast<PrinterMsg::HMessage*>(tmp_msg);
if (loginResp->type() == PrinterMsg::LOGIN_RESPONSE) {
if (loginResp->mutable_response()->result()) {
m_IsLogin = true;
}
}
}
else {
Sleep(3000);
}
}
else if(rcount==-1){
m_Client.Close();
}
}
else if (scount==-1) {
m_Client.Close();
}
}
//delete machineMsg;
return m_IsLogin;
}
bool RemoteClient::AddSendMessage(PrinterMsg::HMessage* msg)
{
if (!msg)return false;
if (!m_WriteFlag) {
delete msg;
msg = NULL;
return false;
}
EnterCriticalSection(&m_MessageCS);
if (m_MessageQueue.size() > 100) {
LeaveCriticalSection(&m_MessageCS);
delete msg;
msg = NULL;
return false;
}
m_MessageQueue.push(msg);
LeaveCriticalSection(&m_MessageCS);
return true;
}
void RemoteClient::PushError(PrinterMsg::MSG msg,string id)
{
PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
respMsg->set_type(msg);
respMsg->set_id(id);
respMsg->set_mcode(m_MachineCfg->m_MachineCode);
PrinterMsg::Response* resp = respMsg->mutable_response();
resp->set_result(false);
ErrorMsg* emsg = resp->mutable_errormsg();
emsg->set_machineid(m_MachineCfg->m_serial);
AddSendMessage(respMsg);
}
void RemoteClient::HandleStateRequest(RemoteClient* client,PrinterMsg::HMessage* msg)
{
PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
respMsg->set_type(PrinterMsg::STATE_RESPONSE);
respMsg->set_id(msg->id());
respMsg->set_mcode(client->m_MachineCfg->m_MachineCode);
EnvInfo info;
g_SystemInfo->GetEnvInfo(info);
StateMsg* stateMsg= respMsg->mutable_response()->mutable_statemsg();
stateMsg->set_oxygenvalue(info.m_OxygenRealTimeValue1);
stateMsg->set_ambienttemp(info.m_AmbientTemp);
stateMsg->set_innertemp(info.m_InnerTemp);
stateMsg->set_windvalue(info.m_WindValue);
stateMsg->set_platformtempvalue(info.m_PlatformTemp);
stateMsg->set_platformtempsettingvalue(info.m_PlatformTempSettingValue);
stateMsg->set_moldpos(info.m_MoldPos/1000.0f);
stateMsg->set_powderpos(info.m_PowderPos);
stateMsg->set_armpos(info.m_ArmPos/1000.0f);
stateMsg->set_printstate(StateMsg::PrintState(BaseCtrl::GetState()));
stateMsg->set_layerindex(g_SystemInfo->m_StateBean.layerIndex);
std::bitset<32> limit;
stateMsg->set_limitflag(limit.to_ulong());
stateMsg->set_machineid(client->m_MachineCfg->m_serial);
stateMsg->set_isdoorclose(info.m_EnvState.m_IsPrintCabinDoorClose);
stateMsg->set_acctime(g_SystemInfo->m_StateBean.realCostSeconds*1000);
stateMsg->set_remaintime(g_SystemInfo->m_StateBean.remainMil);
stateMsg->set_totaltime(g_SystemInfo->m_StateBean.jobCostMil);
stateMsg->set_layercount(g_SystemInfo->m_StateBean.maxLayerIndex);
stateMsg->set_remainpowder(info.m_PowderQty);
EnterCriticalSection(&client->m_JobController->m_cs);
if (client->m_JobController->GetJob()) {
stateMsg->set_material(client->m_JobController->GetJob()->GetMaterialName());
stateMsg->set_jobname(client->m_JobController->GetJob()->GetJobTitle());
stateMsg->set_jobid(client->m_JobController->GetJob()->GetJobUid());
stateMsg->set_taskid(client->m_JobController->GetJob()->m_TaskId);
}
LeaveCriticalSection(&client->m_JobController->m_cs);
respMsg->mutable_response()->set_result(true);
time_t tnow;
time(&tnow);
respMsg->set_sendtime(tnow);
client->AddSendMessage(respMsg);
}
void RemoteClient::HandleJobInfoRequest(RemoteClient* client, PrinterMsg::HMessage* msg)
{
PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
respMsg->set_type(PrinterMsg::JOB_INFO_RESPONSE);
respMsg->set_id(msg->id());
respMsg->set_mcode(client->m_MachineCfg->m_MachineCode);
EnterCriticalSection(&client->m_JobController->m_cs);
if (client->m_JobController->GetJob()==nullptr) {
PrinterMsg::Response* resp = respMsg->mutable_response();
resp->set_result(false);
ErrorMsg* emsg = resp->mutable_errormsg();
emsg->set_machineid(client->m_MachineCfg->m_serial);
client->AddSendMessage(respMsg);
LeaveCriticalSection(&client->m_JobController->m_cs);
return;
}
FileProcessor* job = client->m_JobController->GetJob();
MetaData* metaData = job->GetMetaData();
JobMsg* jobmsg = respMsg->mutable_response()->mutable_jobmsg();
JobInfoMsg* info= jobmsg->mutable_jobinfomsg();
info->set_jobid(job->GetJobUid());
info->set_taskid(job->m_TaskId);
info->set_name(StringHelper::AsciiToUtf8(job->GetJobTitle()));
info->set_material(StringHelper::AsciiToUtf8(job->GetMaterialName()));
info->set_layercount(job->GetLayerCount());
info->set_layerthickness(job->GetLayerThickness());
MetaData::JobDimensions *jd = metaData->GetJobDimensions();
info->set_xsize(jd->xmax - jd->xmin);
info->set_ysize(jd->ymax - jd->ymin);
info->set_zsize(jd->zmax - jd->zmin);
info->set_componentcount(job->GetComponentCount());
metaData->LockPart();
vector<MetaData::Part*> parts= metaData->GetPartVec();
char buffer[123];
//map<int, MetaData::ParameterSet*>* paramMap = metaData->GetParameterMap();
for (size_t i = 0; i < parts.size();i++) {
MetaData::Part* part = parts[i];
PartMsg* pm= jobmsg->add_partmsg();
//sprintf_s(buffer, sizeof(buffer), "%d",i);
pm->set_name(StringHelper::AsciiToUtf8(part->name));
//vector<int>* params= metaData->GetPartRefParameter(part->id);
for (set<MetaData::ParameterSet*>::iterator it = part->paramSet.begin(); it != part->paramSet.end();it++) {
MetaData::ParameterSet* ps = (*it);
ParameterMsg* paramMsg = pm->add_param();
paramMsg->set_type(ps->set_type);
paramMsg->set_laserdiameter(ps->laser_set->laser_diameter);
paramMsg->set_laserpower(ps->laser_set->laser_power);
paramMsg->set_laserspeed(ps->laser_speed);
}
}
metaData->UnLockPart();
respMsg->mutable_response()->set_result(true);
jobmsg->set_machineid(client->m_MachineCfg->m_serial);
LeaveCriticalSection(&client->m_JobController->m_cs);
time_t tnow;
time(&tnow);
respMsg->set_sendtime(tnow);
client->AddSendMessage(respMsg);
}
void RemoteClient::HandleCtrlSystemPause(RemoteClient* client, PrinterMsg::HMessage* msg)
{
PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
respMsg->set_type(PrinterMsg::CTRL_SYSTEM_PAUSE);
respMsg->set_id(msg->id());
respMsg->set_mcode(client->m_MachineCfg->m_MachineCode);
PrinterMsg::Response* resp = respMsg->mutable_response();
if (!BaseCtrl::IsStandBy()) {
bool rel=client->m_ScannerCtrl->PauseWork();
BaseCtrl::SetPauseState(BaseCtrl::ManualPause);
if (rel) {
resp->set_result(true);
}
else {
resp->set_result(false);
ErrorMsg* emsg = resp->mutable_errormsg();
emsg->set_machineid(client->m_MachineCfg->m_serial);
emsg->set_errormsg(client->m_ScannerCtrl->m_PauseMsg);
}
}
else {
resp->set_result(false);
ErrorMsg* emsg = resp->mutable_errormsg();
emsg->set_machineid(client->m_MachineCfg->m_serial);
emsg->set_errormsg(u8"就绪状态不能暂停");
}
client->AddSendMessage(respMsg);
}
void RemoteClient::HandleCtrlSystemStop(RemoteClient* client, PrinterMsg::HMessage* msg)
{
PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
respMsg->set_type(PrinterMsg::CRTL_SYSTEM_STOP);
respMsg->set_id(msg->id());
respMsg->set_mcode(client->m_MachineCfg->m_MachineCode);
PrinterMsg::Response* resp = respMsg->mutable_response();
if (!BaseCtrl::IsStop() && (BaseCtrl::GetState() != BaseCtrl::STANDBY_STOP)) {
bool rel = client->m_ScannerCtrl->StopWork();
if (rel) {
respMsg->mutable_response()->set_result(true);
}
else {
resp->set_result(false);
ErrorMsg* emsg = resp->mutable_errormsg();
emsg->set_machineid(client->m_MachineCfg->m_serial);
emsg->set_errormsg(client->m_ScannerCtrl->m_StopMsg);
}
}
else {
resp->set_result(false);
ErrorMsg* emsg = resp->mutable_errormsg();
emsg->set_machineid(client->m_MachineCfg->m_serial);
emsg->set_errormsg(u8"状态不能暂停");
}
client->AddSendMessage(respMsg);
}
void RemoteClient::HandleLayerDataRequest(RemoteClient* client, PrinterMsg::HMessage* msg)
{
EnterCriticalSection(&client->m_JobController->m_cs);
if (client->m_JobController->GetJob() == nullptr) {
client->PushError(PrinterMsg::LAYER_DATA_RESPONSE,msg->id());
LeaveCriticalSection(&client->m_JobController->m_cs);
return;
}
FileProcessor* job = client->m_JobController->GetJob();
MetaData* job_meta_data = job->GetMetaData();
unsigned int reqindex=msg->request().layerdatamsg().layerindex();
if (!job_meta_data->LoadRemoteLayerByIndex(reqindex)) {
client->PushError(PrinterMsg::LAYER_DATA_RESPONSE, msg->id());
LeaveCriticalSection(&client->m_JobController->m_cs);
return;
}
MetaData::Layer* layer = job_meta_data->GetRemoteLayer();
if (!layer) {
client->PushError(PrinterMsg::LAYER_DATA_RESPONSE, msg->id());
LeaveCriticalSection(&client->m_JobController->m_cs);
return;
}
unsigned int total = 0;
for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
if (!datablock)continue;
MetaData::ParameterSet* paramSet = job_meta_data->GetParameterSet(datablock->references->process);
if (!paramSet)continue;
//if (paramSet->set_type.find("Border") == std::string::npos && paramSet->set_type.find("BorderSupport") == std::string::npos && paramSet->set_type.find("WallSupport") == std::string::npos) {
if ((paramSet->set_type.find("Border") == std::string::npos && paramSet->set_type.find("Support") == std::string::npos) || paramSet->set_type.find("Additional") != std::string::npos) {
continue;
}
MetaData::Part* part = job_meta_data->GetPart(datablock->references->part);
if (part) {
if (!part->print_enable) {
continue;
}
}
BPBinary::BinDataBlock* pdb = job_meta_data->GetRemoteDataBlock(datablock);
if (!pdb) continue;
total++;
}
unsigned int index = 0;
for (size_t blockIndex = 0; blockIndex < layer->data_blocks.size(); ++blockIndex) {
MetaData::DataBlock* datablock = layer->data_blocks[blockIndex];
if (!datablock)continue;
MetaData::ParameterSet* paramSet = job_meta_data->GetParameterSet(datablock->references->process);
if (!paramSet)continue;
//if (paramSet->set_type.find("Border") == std::string::npos && paramSet->set_type.find("BorderSupport") == std::string::npos && paramSet->set_type.find("WallSupport") == std::string::npos) {
if ((paramSet->set_type.find("Border") == std::string::npos && paramSet->set_type.find("Support") == std::string::npos) || paramSet->set_type.find("Additional") != std::string::npos) {
continue;
}
MetaData::Part* part = job_meta_data->GetPart(datablock->references->part);
if (part) {
if (!part->print_enable) {
continue;
}
}
bool ischange = false;
if (client->m_RunCfg->m_OffsetRotateEnable) {
if (part->partPosBean.m_XOffset != 0.0 || part->partPosBean.m_YOffset != 0.0 || part->partPosBean.m_RotateAngle != 0.0) {
ischange = true;
}
}
BPBinary::BinDataBlock* pdb = job_meta_data->GetRemoteDataBlock(datablock);
if (!pdb) continue;
PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
respMsg->set_type(PrinterMsg::LAYER_DATA_RESPONSE);
respMsg->set_id(msg->id());
respMsg->set_mcode(client->m_MachineCfg->m_MachineCode);
PrinterMsg::Response* rep= respMsg->mutable_response();
rep->set_result(true);
LayerDataRespMsg* ldrm= rep->mutable_layerdatamsg();
ldrm->set_machineid(client->m_MachineCfg->m_serial);
ldrm->set_total(total);
ldrm->set_index(index);
ldrm->set_partid(part->id);
ldrm->set_type(pdb->type);
ldrm->set_paramtype(paramSet->set_type);
std::vector<float> data;
if (pdb->type == BIN_VECTOR) {
//ldrm->add_data(pdb->point_indexs.size());
data.push_back(pdb->point_indexs.size());
for (size_t j = 0; j < pdb->point_indexs.size(); ++j) {
BPBinary::VectorPoint* pvp = (BPBinary::VectorPoint*)pdb->point_indexs[j];
float real_x1 = pvp->x1;
float real_y1 = pvp->y1;
float real_x2 = pvp->x2;
float real_y2 = pvp->y2;
if (ischange) {
double mov_x1 = part->partPosBean.m_XOffset + pvp->x1;
double mov_y1 = part->partPosBean.m_YOffset + pvp->y1;
double mov_x2 = part->partPosBean.m_XOffset + pvp->x2;
double mov_y2 = part->partPosBean.m_YOffset + pvp->y2;
real_x1 = (mov_x1 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
real_y1 = (mov_x1 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
real_x2 = (mov_x2 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y2 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
real_y2 = (mov_x2 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y2 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
}
//ldrm->add_data(real_x1);
//ldrm->add_data(real_y1);
//ldrm->add_data(real_x2);
//ldrm->add_data(real_y2);
data.push_back(real_x1);
data.push_back(real_y1);
data.push_back(real_x2);
data.push_back(real_y2);
}
}
else if (pdb->type == BIN_CHAIN) {
//ldrm->add_data(pdb->point_indexs.size());
data.push_back(pdb->point_indexs.size());
for (unsigned int j = 0; j < pdb->point_indexs.size(); ++j) {
BPBinary::ChainPoint* point = (BPBinary::ChainPoint*)pdb->point_indexs[j];
//ldrm->add_data(point->points.size());
data.push_back(point->points.size());
for (unsigned int k = 0; k < point->points.size(); ++k) {
float real_x = point->points[k]->x;
float real_y = point->points[k]->y;
if (ischange) {
double mov_x1 = part->partPosBean.m_XOffset + point->points[k]->x;
double mov_y1 = part->partPosBean.m_YOffset + point->points[k]->y;
real_x = (mov_x1 - part->partPosBean.m_PartCenterX)*cos(part->partPosBean.m_Radians) - (mov_y1 - part->partPosBean.m_PartCenterY)*sin(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterX;
real_y = (mov_x1 - part->partPosBean.m_PartCenterX)*sin(part->partPosBean.m_Radians) + (mov_y1 - part->partPosBean.m_PartCenterY)*cos(part->partPosBean.m_Radians) + part->partPosBean.m_PartCenterY;
}
//ldrm->add_data(real_x);
//ldrm->add_data(real_y);
data.push_back(real_x);
data.push_back(real_y);
}
}
}
std::string *datas_str = new std::string((const char*)&data[0], data.size()*sizeof(float));
ldrm->set_allocated_datas(datas_str);
time_t tnow;
time(&tnow);
respMsg->set_sendtime(tnow);
client->AddSendMessage(respMsg);
index++;
}
LeaveCriticalSection(&client->m_JobController->m_cs);
}
void RemoteClient::HandleCameraStopRequest(RemoteClient* client, PrinterMsg::HMessage* msg)
{
//GalaxyCamera* cam = GalaxyCamera::GetInstance();
if (client->m_Camera && client->m_Camera->IsConnect() && client->m_Camera->GetDemandCatpure() && !client->m_ScannerCtrl->IsStart()) {
client->m_Camera->SetDemandCatpure(false);
}
}
void RemoteClient::HandleCameraDataRequest(RemoteClient* client, PrinterMsg::HMessage* msg)
{
PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
respMsg->set_type(PrinterMsg::CAMERA_DATA_RESPONSE);
respMsg->set_id(msg->id());
respMsg->set_mcode(client->m_MachineCfg->m_MachineCode);
HBDCamera* cam = client->m_Camera;
PrinterMsg::Response* resp = respMsg->mutable_response();
CameraDataMsg* cdm = resp->mutable_cameradata();
if (!cam->IsConnect())
{
if (!cam->GetDemandCatpure())
cam->SetDemandCatpure(true);
resp->set_result(false);
time_t tnow;
time(&tnow);
respMsg->set_sendtime(tnow);
client->AddSendMessage(respMsg);
return;
}
cv::Mat image;
cam->GetRemoteShowImageMat(image);
if (image.data)
{
bool needReduceImage = false;
if (image.cols * image.rows > 1200000) {
needReduceImage = true;
}
float ratio = ConfigManager::GetInstance()->GetExtCfg()->m_LogRatio;
cv::Mat fixImage;
if (!client->m_ExtCfg->m_UseShowImageWarpPerspective) {
if (needReduceImage) {
cv::resize(image, fixImage, cv::Size(0, 0), ratio, ratio);
}
else {
image.copyTo(fixImage);
}
int cols = fixImage.cols - 1;
int rows = fixImage.rows - 1;
cv::Point2f center(cols / 2.0, rows / 2.0);
double rad = MathHelper::DegreesToRadians(client->m_ExtCfg->m_ShowImageAngle);
int topLeftx = (0 - center.x) * cos(rad) - (0 - center.y) * sin(rad) + center.x;
int topLefty = (0 - center.y) * cos(rad) + (0 - center.x) * sin(rad) + center.y;
if (topLeftx < 0)topLeftx = 0; if (topLeftx > cols)topLeftx = cols;
if (topLefty < 0)topLefty = 0; if (topLefty > rows)topLefty = rows;
int topRightx = (cols - center.x) * cos(rad) - (0 - center.y) * sin(rad) + center.x;
int topRighty = (0 - center.y) * cos(rad) + (cols - center.x) * sin(rad) + center.y;
if (topRightx < 0)topRightx = 0; if (topRightx > cols)topRightx = cols;
if (topRighty < 0)topRighty = 0; if (topRighty > rows)topRighty = rows;
int btnRightx = (cols - center.x) * cos(rad) - (rows - center.y) * sin(rad) + center.x;
int btnRighty = (rows - center.y) * cos(rad) + (cols - center.x) * sin(rad) + center.y;
if (btnRightx < 0)btnRightx = 0; if (btnRightx > cols)btnRightx = cols;
if (btnRighty < 0)btnRighty = 0; if (btnRighty > rows)btnRighty = rows;
int btnLeftx = (0 - center.x) * cos(rad) - (rows - center.y) * sin(rad) + center.x;
int btnLefty = (rows - center.y) * cos(rad) + (0 - center.x) * sin(rad) + center.y;
if (btnLeftx < 0)btnLeftx = 0; if (btnLeftx > cols)btnLeftx = cols;
if (btnLefty < 0)btnLefty = 0; if (btnLefty > rows)btnLefty = rows;
cv::Point2f srcTri[4];
srcTri[0] = cv::Point2f(topLeftx, topLefty);
srcTri[1] = cv::Point2f(topRightx, topRighty);
srcTri[2] = cv::Point2f(btnRightx, btnRighty);
srcTri[3] = cv::Point2f(btnLeftx, btnLefty);
cv::Point2f tempTri[4];
tempTri[0] = cv::Point2f(0.0f, 0.0f);
tempTri[1] = cv::Point2f((float)client->m_ExtCfg->m_ShowImagePerspectiveWidth, 0.0f);
tempTri[2] = cv::Point2f((float)client->m_ExtCfg->m_ShowImagePerspectiveWidth, (float)client->m_ExtCfg->m_ShowImagePerspectiveHeigh);
tempTri[3] = cv::Point2f(0.0f, (float)client->m_ExtCfg->m_ShowImagePerspectiveHeigh);
cv::Mat warp_mat = cv::getPerspectiveTransform(srcTri, tempTri);
cv::Mat tempImage = cv::Mat(cv::Size(client->m_ExtCfg->m_ShowImagePerspectiveWidth, client->m_ExtCfg->m_ShowImagePerspectiveHeigh), CV_8U);
warpPerspective(fixImage, tempImage, warp_mat, tempImage.size());
fixImage.release();
fixImage = tempImage;
}
else {
cv::Point2f srcTri[4];
if (needReduceImage) {
cv::resize(image, fixImage, cv::Size(0, 0), ratio, ratio);
srcTri[0] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageTopLeftX*ratio, (float)client->m_ExtCfg->m_ShowImageTopLeftY*ratio);
srcTri[1] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageTopRightX*ratio, (float)client->m_ExtCfg->m_ShowImageTopRightY*ratio);
srcTri[2] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageBottomRightX*ratio, (float)client->m_ExtCfg->m_ShowImageBottomRightY*ratio);
srcTri[3] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageBottomLeftX*ratio, (float)client->m_ExtCfg->m_ShowImageBottomLeftY*ratio);
}
else {
image.copyTo(fixImage);
srcTri[0] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageTopLeftX, (float)client->m_ExtCfg->m_ShowImageTopLeftY);
srcTri[1] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageTopRightX, (float)client->m_ExtCfg->m_ShowImageTopRightY);
srcTri[2] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageBottomRightX, (float)client->m_ExtCfg->m_ShowImageBottomRightY);
srcTri[3] = cv::Point2f((float)client->m_ExtCfg->m_ShowImageBottomLeftX, (float)client->m_ExtCfg->m_ShowImageBottomLeftY);
}
cv::Point2f tempTri[4];
tempTri[0] = cv::Point2f(0.0f, 0.0f);
tempTri[1] = cv::Point2f((float)client->m_ExtCfg->m_ShowImagePerspectiveWidth, 0.0f);
tempTri[2] = cv::Point2f((float)client->m_ExtCfg->m_ShowImagePerspectiveWidth, (float)client->m_ExtCfg->m_ShowImagePerspectiveHeigh);
tempTri[3] = cv::Point2f(0.0f, (float)client->m_ExtCfg->m_ShowImagePerspectiveHeigh);
cv::Mat warp_mat = cv::getPerspectiveTransform(srcTri, tempTri);
cv::Mat tempImage = cv::Mat(cv::Size(client->m_ExtCfg->m_ShowImagePerspectiveWidth, client->m_ExtCfg->m_ShowImagePerspectiveHeigh), CV_8U);
warpPerspective(fixImage, tempImage, warp_mat, tempImage.size());
fixImage.release();
fixImage = tempImage;
}
image.release();
std::vector<unsigned char> dataEncode;
vector<int> compression_params;
compression_params.push_back(cv::IMWRITE_JPEG_QUALITY);
compression_params.push_back(60);
cv::imencode(".jpg", fixImage, dataEncode, compression_params);
if (dataEncode.empty()) {
resp->set_result(false);
}
else {
resp->set_result(true);
cdm->set_machineid(client->m_MachineCfg->m_serial);
cdm->set_imageformat("jpg");
cdm->set_imagewidth(fixImage.cols);
cdm->set_imageheight(fixImage.rows);
cdm->set_imagedatasize(dataEncode.size());
string* imageData = new string((char*)&dataEncode[0], dataEncode.size());
cdm->set_allocated_imagedatas(imageData);
dataEncode.clear();
}
fixImage.release();
}
else {
resp->set_result(false);
}
time_t tnow;
time(&tnow);
respMsg->set_sendtime(tnow);
client->AddSendMessage(respMsg);
}
void RemoteClient::HandleAlarmNotifyResponse(RemoteClient* client, PrinterMsg::HMessage* msg)
{
client->SetNeedSendAlarm(false);
}
void RemoteClient::HandleStateChangeResponse(RemoteClient* client, PrinterMsg::HMessage* msg)
{
client->SetNeedSendFinish(false);
}
void RemoteClient::SendStateChangeMsg()
{
if (!m_IsLogin)
return;
PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
respMsg->set_type(PrinterMsg::STATE_CHANGE);
respMsg->set_id(m_MachineCfg->m_serial);
respMsg->set_mcode(m_MachineCfg->m_MachineCode);
EnvInfo info;
g_SystemInfo->GetEnvInfo(info);
StateChangeMsg* stateMsg = respMsg->mutable_response()->mutable_statechangemsg();
stateMsg->set_oxygenvalue(info.m_OxygenRealTimeValue1);
stateMsg->set_ambienttemp(info.m_AmbientTemp);
stateMsg->set_innertemp(info.m_InnerTemp);
stateMsg->set_windvalue(info.m_WindValue);
stateMsg->set_platformtempvalue(info.m_PlatformTemp);
stateMsg->set_platformtempsettingvalue(info.m_PlatformTempSettingValue);
stateMsg->set_moldpos(info.m_MoldPos/1000.0f);
stateMsg->set_powderpos(info.m_PowderPos);
stateMsg->set_armpos(info.m_ArmPos/1000.0f);
stateMsg->set_printstate(StateChangeMsg::PrintState(BaseCtrl::GetState()));
stateMsg->set_layerindex(g_SystemInfo->m_StateBean.layerIndex);
std::bitset<32> limit;
stateMsg->set_limitflag(limit.to_ulong());
stateMsg->set_machineid(m_MachineCfg->m_serial);
stateMsg->set_isdoorclose(info.m_EnvState.m_IsPrintCabinDoorClose);
stateMsg->set_acctime(g_SystemInfo->m_StateBean.realCostSeconds * 1000);
stateMsg->set_remaintime(g_SystemInfo->m_StateBean.remainMil);
stateMsg->set_totaltime(g_SystemInfo->m_StateBean.jobCostMil);
stateMsg->set_layercount(g_SystemInfo->m_StateBean.maxLayerIndex);
stateMsg->set_remainpowder(info.m_PowderQty);
EnterCriticalSection(&m_JobController->m_cs);
if (m_JobController->GetJob()) {
stateMsg->set_material(m_JobController->GetJob()->GetMaterialName());
stateMsg->set_jobname(m_JobController->GetJob()->GetJobTitle());
stateMsg->set_jobid(m_JobController->GetJob()->GetJobUid());
stateMsg->set_taskid(m_JobController->GetJob()->m_TaskId);
}
LeaveCriticalSection(&m_JobController->m_cs);
respMsg->mutable_response()->set_result(true);
time_t tnow;
time(&tnow);
respMsg->set_sendtime(tnow);
AddSendMessage(respMsg);
}
void RemoteClient::SendAlarmMsg(AlarmShowInfo* info)
{
if (!info)return;
if (!m_IsLogin)return;
m_AlarmInfo.m_AlarmCode = info->m_AlarmCode;
m_AlarmInfo.m_JobName = info->m_JobName;
m_AlarmInfo.m_JobId = info->m_JobId;
m_AlarmInfo.m_HappenTime = info->m_HappenTime;
m_AlarmInfo.m_LayerIndex = info->m_LayerIndex;
m_AlarmInfo.m_AlarmName = info->m_AlarmName;
m_AlarmInfo.m_AlarmContent = info->m_AlarmContent;
m_AlarmInfo.m_AlarmShowInfo = info->m_AlarmShowInfo;
m_AlarmInfo.m_AlarmType = info->m_AlarmType;
m_AlarmInfo.m_TFlag = info->m_TFlag;
m_AlarmInfo.m_HadSendEmail = info->m_HadSendEmail;
PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
respMsg->set_type(PrinterMsg::ALARM_NOTIFY_REQUEST);
respMsg->set_id(m_MachineCfg->m_serial);
respMsg->set_mcode(m_MachineCfg->m_MachineCode);
AlarmNotifyMsg* msg = respMsg->mutable_request()->mutable_alarmnotifymsg();
msg->set_jobname(m_AlarmInfo.m_JobName);
msg->set_jobid(m_AlarmInfo.m_JobId);
msg->set_happentime(m_AlarmInfo.m_HappenTime);
msg->set_layerindex(m_AlarmInfo.m_LayerIndex);
msg->set_alarmtype(m_AlarmInfo.m_AlarmType);
msg->set_alarmcode(m_AlarmInfo.m_AlarmCode);
msg->set_alarmcontent(m_AlarmInfo.m_AlarmContent);
time_t tnow;
time(&tnow);
respMsg->set_sendtime(tnow);
AddSendMessage(respMsg);
}
void RemoteClient::HandleRecordTasksMsg(RemoteClient* client, PrinterMsg::HMessage* msg)
{
if (!msg->request().has_reqrecordtaskmsg())return;
PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
respMsg->set_type(PrinterMsg::LOG_RESPONSE_RECORD_TASK);
respMsg->set_id(msg->id());
respMsg->set_mcode(client->m_MachineCfg->m_MachineCode);
PrinterMsg::Response* resp = respMsg->mutable_response();
vector<JobBean*> logs;
g_log->m_LogDao->GetJobsByTaskId(msg->request().reqrecordtaskmsg().taskid(),logs);
RecordTasksMsg* rtm= resp->mutable_recordtasksmsg();
for (size_t i = 0; i < logs.size();i++) {
JobBean* job = logs[i];
RecordTaskMsg* record = rtm->add_recordtasks();
record->set_id(job->m_Id);
record->set_taskid(job->m_TaskID);
record->set_name(job->m_Name);
record->set_begintime(TimeHelper::Time2Str(job->m_StartTime));
record->set_endtime(TimeHelper::Time2Str(job->m_StopTime));
record->set_deoxygensecond(job->m_DeoxygenSecond);
record->set_totalusesecond(job->m_SpendSecond);
record->set_logmoldposition(job->m_MoldPos);
record->set_finishlayer(job->m_PrintedLayerIndex);
record->set_isfinish(job->m_IsFinished);
record->set_iscontinueprint(job->m_IsContinue);
}
respMsg->mutable_response()->set_result(true);
time_t tnow;
time(&tnow);
respMsg->set_sendtime(tnow);
client->AddSendMessage(respMsg);
for (size_t i = 0; i < logs.size(); i++) {
delete logs[i];
}
logs.clear();
}
void RemoteClient::HandleRecordTasksListMsg(RemoteClient* client, PrinterMsg::HMessage* msg)
{
if (!msg->request().has_reqrecordtaskmsg())return;
PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
respMsg->set_type(PrinterMsg::LOG_RESPONSE_RECORD_TASK_LIST);
respMsg->set_id(msg->id());
respMsg->set_mcode(client->m_MachineCfg->m_MachineCode);
PrinterMsg::Response* resp = respMsg->mutable_response();
tm begin;
time_t begin_t = msg->request().reqrecordtasklistmsg().beginsecond();
localtime_s(&begin, &begin_t);
tm end;
time_t end_t = msg->request().reqrecordtasklistmsg().endsecond();
localtime_s(&end, &end_t);
if (end_t <= begin_t || (end_t-begin_t)>60*60*24*90) {
respMsg->mutable_response()->set_result(true);
ErrorMsg* emsg = resp->mutable_errormsg();
emsg->set_machineid(client->m_MachineCfg->m_serial);
emsg->set_errormsg("error time params");
time_t tnow;
time(&tnow);
respMsg->set_sendtime(tnow);
client->AddSendMessage(respMsg);
return;
}
vector<JobBean*> logs;
g_log->m_LogDao->GetJobsByTime(begin, end, logs);
RecordTasksListMsg* rtm = resp->mutable_recordtasklistmsg();
for (size_t i = 0; i < logs.size(); i++) {
JobBean* job = logs[i];
RecordTaskMsg* record = rtm->add_recordtaskslist();
record->set_id(job->m_Id);
record->set_taskid(job->m_TaskID);
record->set_name(job->m_Name);
record->set_begintime(TimeHelper::Time2Str(job->m_StartTime));
record->set_endtime(TimeHelper::Time2Str(job->m_StopTime));
record->set_deoxygensecond(job->m_DeoxygenSecond);
record->set_totalusesecond(job->m_SpendSecond);
record->set_logmoldposition(job->m_MoldPos);
record->set_finishlayer(job->m_PrintedLayerIndex);
record->set_isfinish(job->m_IsFinished);
record->set_iscontinueprint(job->m_IsContinue);
}
respMsg->mutable_response()->set_result(true);
time_t tnow;
time(&tnow);
respMsg->set_sendtime(tnow);
client->AddSendMessage(respMsg);
for (size_t i = 0; i < logs.size(); i++) {
delete logs[i];
}
logs.clear();
}
void RemoteClient::HandleVersionResMsg(RemoteClient* client, PrinterMsg::HMessage* msg)
{
PrinterMsg::HMessage* respMsg = new PrinterMsg::HMessage();
respMsg->set_type(PrinterMsg::VERSION_RESPONSE);
respMsg->set_id(msg->id());
respMsg->set_mcode(client->m_MachineCfg->m_MachineCode);
PrinterMsg::Response* resp = respMsg->mutable_response();
VersionInfoResMsg* versionInfo = resp->mutable_versioninforesmsg();
versionInfo->set_version(g_SystemInfo->m_ProductVersion);
resp->set_result(true);
time_t tnow;
time(&tnow);
respMsg->set_sendtime(tnow);
client->AddSendMessage(respMsg);
}
Reference in New Issue View Git Blame Copy Permalink