bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
VisualizationMono_Sensor_Laser_Params * params=(VisualizationMono_Sensor_Laser_Params *)paramsPtr;
VisualizationMono_Sensor_Laser_Vars * vars=(VisualizationMono_Sensor_Laser_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader,params,range);
GetParamValue(xmlloader,params,interval);
GetParamValue(xmlloader,params,imageradius);
GetParamValue(xmlloader,params,frontonly);
GetParamValue(xmlloader,params,laserbeam);
GetParamValue(xmlloader,params,calib_width);
GetParamValue(xmlloader,params,calib_height);
vars->beams->setText("Opened");
return 1;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
SensorInternalEvent_Sensor_Laser_Params * params=(SensorInternalEvent_Sensor_Laser_Params *)paramsPtr;
Simulator_Sensor_Laser_Vars * vars=(Simulator_Sensor_Laser_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader,vars,path);
GetParamValue(xmlloader,vars,filename);
GetParamValue(xmlloader,params,first_step);
GetParamValue(xmlloader,params,last_step);
GetParamValue(xmlloader,params,skip_step);
GetParamValue(xmlloader,params,nearfilter);
GetParamValue(xmlloader,params,farfilter);
vars->file.setFileName(QString("%1%2").arg(vars->path).arg(vars->filename));
if(!vars->file.open(QIODevice::ReadOnly))
{
return 0;
}
vars->file.read(sizeof(float)*3);//文件头
return 1;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
VisualizationMono_Sensor_stm32comm_Params * params=(VisualizationMono_Sensor_stm32comm_Params *)paramsPtr;
VisualizationMono_Sensor_stm32comm_Vars * vars=(VisualizationMono_Sensor_stm32comm_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
//vars->comm_label->setText("open");
GetParamValue(xmlloader,params,mapsize);
GetParamValue(xmlloader,params,pixelsize);
GetParamValue(xmlloader,vars,showheight);
vars->mapzero.x = 0;
vars->mapzero.y = 0;
vars->map.create(cv::Size(params->mapsize,params->mapsize),CV_8UC3);
vars->map.setTo(0);
vars->qmap->setText("Opened");
return 1;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
Simulator_Sensor_Velodyne_Params * params=(Simulator_Sensor_Velodyne_Params *)paramsPtr;
SensorInternalEvent_ROS_Sensor_Velodyne_Vars * vars=(SensorInternalEvent_ROS_Sensor_Velodyne_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader,params,velodynecalibfile);
QFile file;
file.setFileName(params->velodynecalibfile);
if(!file.exists()||!file.open(QIODevice::ReadOnly|QIODevice::Text))
{
return 0;
}
while(!file.atEnd())
{
QString tmpstr=file.readLine();
int tmpindex=tmpstr.indexOf(":");
if(tmpindex<0)
{
continue;
}
QString prefix=tmpstr.left(tmpindex).trimmed();
QString suffix=tmpstr.mid(tmpindex+1).trimmed();
QStringList values=suffix.split(QChar(' '),QString::SkipEmptyParts);
if(prefix.startsWith(QString("R")))
{
int i,n=values.size();
for(i=0;i<n;i++)
{
int row=i/3;
int col=i%3;
params->calib2camera(row,col)=values[i].toFloat();
}
}
else if(prefix.startsWith(QString("T")))
{
int i,n=values.size();
for(i=0;i<n;i++)
{
params->calib2camera(i,3)=values[i].toFloat();
}
}
}
file.close();
vars->velodynesub->startReceiveSlot();
return 1;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
StorageMono_Algorithm_Integration_VelodyneCamera_Params * params=(StorageMono_Algorithm_Integration_VelodyneCamera_Params *)paramsPtr;
StorageMono_Algorithm_Integration_VelodyneCamera_Vars * vars=(StorageMono_Algorithm_Integration_VelodyneCamera_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
return 1;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
SourceDrainMono_Sensor_stm32comm_Params * params=(SourceDrainMono_Sensor_stm32comm_Params *)paramsPtr;
SourceDrainMono_Sensor_stm32comm_Vars * vars=(SourceDrainMono_Sensor_stm32comm_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader, params, port);
GetEnumParamValue(xmlloader, params, baudrate);
GetEnumParamValue(xmlloader, params, qurymodel);
GetParamValue(xmlloader, params, recv_packhead);
GetParamValue(xmlloader, params, recv_packtail);
GetParamValue(xmlloader, params, send_packhead);
GetParamValue(xmlloader, params, send_packtail);
GetParamValue(xmlloader, params, distPerPulse);
GetParamValue(xmlloader, params, maxpusle);
GetParamValue(xmlloader, params, WheelBase);
GetParamValue(xmlloader, params, WheelRadius);
GetParamValue(xmlloader, params, ratio);
GetParamValue(xmlloader, vars, quryinterval);
GetParamValue(xmlloader, params, recvpacksize);
GetParamValue(xmlloader, vars, encoderrange);
vars->serialport->setPortName(params->port);
vars->serialport->setBaudRate(params->baudrate);
vars->serialport->setDataBits(params->databits);
vars->serialport->setParity(params->parity);
vars->serialport->setStopBits(params->stopbits);
vars->serialport->setFlowControl(params->flowtype);
vars->serialport->setTimeout(params->timeout);
vars->serialport->setQueryMode(params->qurymodel);
vars->leftspeed = vars->rightspeed =0;
vars->leftodom = vars->rightodom = 0;
vars->x = vars->y = vars->theta = vars->yaw = 0;
if(!(vars->serialport->open(QIODevice::ReadWrite)))
return 0;
return 1;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
TransmitterMono_Gazebo_OrderGenerate_Params * params=(TransmitterMono_Gazebo_OrderGenerate_Params *)paramsPtr;
TransmitterMono_Gazebo_OrderGenerate_Vars * vars=(TransmitterMono_Gazebo_OrderGenerate_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader, vars, vel_ratio)
return 1;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
VisualizationMono_Processor_SimpleCollect_Params * params=(VisualizationMono_Processor_SimpleCollect_Params *)paramsPtr;
VisualizationMono_Processor_SimpleCollect_Vars * vars=(VisualizationMono_Processor_SimpleCollect_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
vars->label->setAlignment(Qt::AlignCenter);
vars->label->setText("opened");
return 1;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
VisualizationMulti_Algorithm_Detection_DPM_Params * params=(VisualizationMulti_Algorithm_Detection_DPM_Params *)paramsPtr;
VisualizationMulti_Algorithm_Detection_DPM_Vars * vars=(VisualizationMulti_Algorithm_Detection_DPM_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
vars->viewer->setText("Open");
vars->camerabuffer.clear();
vars->dpmbuffer.clear();
return 1;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
VisualizationMulti_Visualization_Integration_GroundObjectsDBM_Params * params=(VisualizationMulti_Visualization_Integration_GroundObjectsDBM_Params *)paramsPtr;
VisualizationMulti_Visualization_Integration_GroundObjectsDBM_Vars * vars=(VisualizationMulti_Visualization_Integration_GroundObjectsDBM_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader,vars,radius);
GetParamValue(xmlloader,vars,thickness);
GetParamValue(xmlloader,vars,range);
vars->image->setText("Open");
vars->init=1;
return 1;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
VisualizationMulti_VisualMisc_ControlJoy_Params * params=(VisualizationMulti_VisualMisc_ControlJoy_Params *)paramsPtr;
VisualizationMulti_VisualMisc_ControlJoy_Vars * vars=(VisualizationMulti_VisualMisc_ControlJoy_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader, vars, leftArrowPath);
GetParamValue(xmlloader, vars, rightArrowPath);
GetParamValue(xmlloader, vars, forwardArrowPath);
GetParamValue(xmlloader, vars, backArrowPath);
GetParamValue(xmlloader, vars, width);
GetParamValue(xmlloader, vars, height);
GetParamValue(xmlloader, vars, fontSize);
std::cout<<"open Joystick\n";
vars->label->setText("Open");
bool flag = vars->leftArrowImg.load(vars->leftArrowPath);
flag &= vars->rightArrowImg.load(vars->rightArrowPath);
flag &= vars->forwardArrowImg.load(vars->forwardArrowPath);
flag &= vars->backArrowImg.load(vars->backArrowPath);
if(!flag)
{
std::cout<<"load image error: VisualizationMulti_ControlJoy !"<<std::endl;
return 0;
}
return 1;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
VisualizationMono_Processor_PathGenerator_Params * params=(VisualizationMono_Processor_PathGenerator_Params *)paramsPtr;
VisualizationMono_Processor_PathGenerator_Vars * vars=(VisualizationMono_Processor_PathGenerator_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader, vars, offlineTrajecPath);
GetParamValue(xmlloader, vars, offlineTrajecFilename);
FILE *fp = fopen((vars->offlineTrajecPath+vars->offlineTrajecFilename).toStdString().c_str(), "r");
double ox, oy, oth;
while (fscanf(fp, "%lf %lf %lf", &ox, &oy, &oth) == 3)
{
trajec_state tmp = {ox, oy, oth, 0};
vars->offlinetrajec.push_back(tmp);
}
fclose(fp);
vars->glviewer->makeCurrent();
vars->glviewer->setBackground(QColor(241,241,241));
vars->glviewer->clearDisplayList();
vars->displaylistbase = glGenLists(vars->shownum);
int i;
for(i=0; i<vars->shownum; i++)
vars->glviewer->addDisplayList(vars->displaylistbase + i);
vars->lastPos.x = vars->lastPos.y = 0;
return 1;
}
bool DECOFUNC(setParamsVarsOpenNode)(QString qstrConfigName, QString qstrNodeType, QString qstrNodeClass, QString qstrNodeName, void * paramsPtr, void * varsPtr)
{
XMLDomInterface xmlloader(qstrConfigName,qstrNodeType,qstrNodeClass,qstrNodeName);
ProcessorMono_Algorithm_Detection_Camera_DBM_Params * params=(ProcessorMono_Algorithm_Detection_Camera_DBM_Params *)paramsPtr;
ProcessorMono_Algorithm_Detection_Camera_DBM_Vars * vars=(ProcessorMono_Algorithm_Detection_Camera_DBM_Vars *)varsPtr;
/*======Please Program below======*/
/*
Function: open node.
Procedure:
1: load parameters (params). [GetParamValue(xmlloader,params,tag); GetEnumParamValue(xmlloader,params,tag); GetUEnumParamValue(xmlloader,params,tag)]
2: initialize variables (vars).
3: If everything is OK, return 1 for successful opening and vice versa.
*/
GetParamValue(xmlloader,vars,modeldir);
GetParamValue(xmlloader,vars,threshold1);
GetParamValue(xmlloader,vars,threshold2);
GetParamValue(xmlloader,vars,threadnum);
GetParamValue(xmlloader,vars,compressrate);
GetParamValue(xmlloader,vars,grubsize);
if(vars->modeldir.size()==0)
{
return 0;
}
QDir dir(vars->modeldir);
if(dir.exists())
{
dir.setFilter(QDir::Files);
dir.setNameFilters(QStringList()<<"*.xml");
QFileInfoList files=dir.entryInfoList();
int i,n=files.size();
std::vector<std::string> modelfiles;
for(i=0;i<n;i++)
{
modelfiles.push_back(files[i].absoluteFilePath().toStdString());
}
if(n>0)
{
if(!vars->detector.load(modelfiles))
{
return 0;
}
modelfiles=vars->detector.getClassNames();
n=vars->detector.getClassCount();
params->classes.resize(n);
for(i=0;i<n;i++)
{
params->classes[i]=QString::fromStdString(modelfiles[i]);
}
vars->init=1;
return 1;
}
else
{
return 0;
}
}
else
{
return 0;
}
}
