const char*
QgarArgs::getStringOptionMulti (const char* aFlag, int anIdx) const
{
QgarParam* pParam = findParam(aFlag);
// The parameter must be declared
if (pParam == 0)
{
ostringstream os;
os << "Unknown flag: "
<< aFlag;
throw QgarErrorUser(__FILE__, __LINE__,
"const char* qgar::QgarArgs::getStringOptionMulti (const char*, int) const",
os.str());
}
// The flag must match a multi-valued parameter and a valid index
if ( ( (pParam->paramStatus() != OPTMULTIPARAM) &&
(pParam->paramStatus() != REQMULTIPARAM) )
||
(anIdx > pParam->numbOptions()))
{
ostringstream os;
os << "Flag "
<< aFlag
<< " should match a multi-valued parameter and a valid index.";
throw QgarErrorUser(__FILE__, __LINE__,
"const char* qgar::QgarArgs::getStringOptionMulti (const char*, int) const",
os.str());
}
return pParam->argument(anIdx);
}
bool
QgarArgs::isOptionSet(const char *aFlag) const
{
QgarParam* pParam = findParam(aFlag);
// The parameter must be declared
if (pParam == 0)
{
ostringstream os;
os << "Unknown flag: "
<< aFlag;
throw QgarErrorUser(__FILE__, __LINE__,
"bool qgar::QgarArgs::isOptionSet(const char*) const",
os.str());
}
// The flag must be optional
if ((pParam->paramStatus() != SINGLEFLAG) &&
(pParam->paramStatus() != OPTPARAM) &&
(pParam->paramStatus() != OPTMULTIPARAM))
{
ostringstream os;
os << "Flag "
<< aFlag
<< " should be optional.";
throw QgarErrorUser(__FILE__, __LINE__,
"bool qgar::QgarArgs::isOptionSet(const char*) const",
os.str());
}
return pParam->useFlag();
}
/****************************************************************************
Desc: Stores a new value for the specified name (or creates a new name/value
pair) in the list of INI_STRUCTs
****************************************************************************/
RCODE FTKAPI F_IniFile::setParam(
const char * pszParamName,
const char * pszParamVal)
{
RCODE rc = NE_FLM_OK;
INI_LINE * pLine;
f_assert( m_bReady);
// If the parameter exists in the list, just store the new value.
// Othewise, create a new INI_LINE and add it to the list
pLine = findParam( pszParamName);
if( !pLine)
{
if( RC_BAD( rc = setParamCommon( &pLine, pszParamName)))
{
goto Exit;
}
}
if( RC_BAD( rc = toAscii( &pLine->pszParamValue, pszParamVal)))
{
goto Exit;
}
Exit:
return( rc);
}
/****************************************************************************
Desc: Retrieves the value associated with the specified name from the list
of INI_STRUCTs
****************************************************************************/
FLMBOOL FTKAPI F_IniFile::getParam(
const char * pszParamName,
char ** ppszParamVal)
{
FLMBOOL bFound = FALSE;
INI_LINE * pLine = NULL;
f_assert( m_bReady);
*ppszParamVal = NULL;
pLine = findParam( pszParamName);
if( !pLine)
{
goto Exit;
}
if( pLine->pszParamValue == NULL)
{
goto Exit;
}
*ppszParamVal = pLine->pszParamValue;
bFound = TRUE;
Exit:
return( bFound);
}
/****************************************************************************
Desc: Retrieves the value associated with the specified name from the list
of INI_STRUCTs
****************************************************************************/
FLMBOOL FTKAPI F_IniFile::getParam(
const char * pszParamName,
FLMBOOL * pbParamVal) // Out: The value associated with name
{
FLMBOOL bFound = FALSE;
INI_LINE * pLine = NULL;
f_assert( m_bReady);
pLine = findParam( pszParamName);
if( !pLine)
{
goto Exit;
}
if( !pLine->pszParamValue)
{
goto Exit;
}
fromAscii( pbParamVal, pLine->pszParamValue);
bFound = TRUE;
Exit:
return( bFound);
}
const char*
QgarArgs::getStringOption(const char* aFlag, bool aSpecial) const
{
QgarParam* pParam = findParam(aFlag);
// The parameter must be declared
if (pParam == 0)
{
ostringstream os;
os << "Unknown flag: "
<< aFlag;
throw QgarErrorUser(__FILE__, __LINE__,
"const char* qgar::QgarArgs::getStringOption(const char*, bool) const",
os.str());
}
// The flag must match a single parameter
if ((pParam->paramStatus() != OPTPARAM) && (pParam->paramStatus() != REQPARAM))
{
ostringstream os;
os << "Flag "
<< aFlag
<< " should match a single parameter.";
throw QgarErrorUser(__FILE__, __LINE__,
"const char* qgar::QgarArgs::getStringOption(const char*, bool) const",
os.str());
}
return pParam->value(aSpecial);
}
/****************************************************************************
Desc: Retrieves the value associated with the specified name from the list
of INI_STRUCTs
****************************************************************************/
FLMBOOL FTKAPI F_IniFile::getParam(
const char * pszParamName,
FLMUINT * puiParamVal)
{
FLMBOOL bFound = FALSE;
INI_LINE * pLine = NULL;
f_assert( m_bReady);
pLine = findParam( pszParamName);
if( !pLine)
{
goto Exit;
}
if( !pLine->pszParamValue)
{
goto Exit;
}
fromAscii( puiParamVal, pLine->pszParamValue);
bFound = TRUE;
Exit:
return( bFound);
}
int
QgarArgs::getNumberOptions(const char* aFlag) const
{
QgarParam* pParam = findParam(aFlag);
// The parameter must be declared
if (pParam == 0)
{
ostringstream os;
os << "Unknown flag: "
<< aFlag;
throw QgarErrorUser(__FILE__, __LINE__,
"int qgar::QgarArgs::getNumberOptions(const char*) const",
os.str());
}
// The flag must match a multi-valued parameter
if ((pParam->paramStatus() != OPTMULTIPARAM) && (pParam->paramStatus() != REQMULTIPARAM))
{
ostringstream os;
os << "Flag "
<< aFlag
<< " should match a multi-valued parameter.";
throw QgarErrorUser(__FILE__, __LINE__,
"int qgar::QgarArgs::getNumberOptions(const char*) const",
os.str());
}
return pParam->numbOptions();
}
int GhostBlockBrickedVolume::setRegion(
// points to the first voxel to be copied. The voxels at 'source' MUST
// have dimensions 'regionSize', must be organized in 3D-array order, and
// must have the same voxel type as the volume.
const void *source,
// coordinates of the lower, left, front corner of the target region
const vec3i ®ionCoords,
// size of the region that we're writing to, MUST be the same as the
// dimensions of source[][][]
const vec3i ®ionSize)
{
// Create the equivalent ISPC volume container and allocate memory for voxel
// data.
if (ispcEquivalent == nullptr)
createEquivalentISPC();
/*! \todo check if we still need this 'computevoxelrange' - in
theory we need this only if the app is allowed to query these
values, and they're not being set in sharedstructuredvolume,
either, so should we actually set them at all!? */
// Compute the voxel value range for unsigned byte voxels if none was
// previously specified.
Assert2(source,"nullptr source in GhostBlockBrickedVolume::setRegion()");
#ifndef OSPRAY_VOLUME_VOXELRANGE_IN_APP
if (findParam("voxelRange") == NULL) {
// Compute the voxel value range for float voxels if none was
// previously specified.
const size_t numVoxelsInRegion
= (size_t)regionSize.x *
+ (size_t)regionSize.y *
+ (size_t)regionSize.z;
if (voxelType == "uchar")
computeVoxelRange((unsigned char *)source, numVoxelsInRegion);
else if (voxelType == "ushort")
computeVoxelRange((unsigned short *)source, numVoxelsInRegion);
else if (voxelType == "float")
computeVoxelRange((float *)source, numVoxelsInRegion);
else if (voxelType == "double")
computeVoxelRange((double *) source, numVoxelsInRegion);
else {
throw std::runtime_error("invalid voxelType in "
"GhostBlockBrickedVolume::setRegion()");
}
}
#endif
// Copy voxel data into the volume.
const int NTASKS = regionSize.y * regionSize.z;
parallel_for(NTASKS, [&](int taskIndex){
ispc::GBBV_setRegion(ispcEquivalent,
source,
(const ispc::vec3i &)regionCoords,
(const ispc::vec3i &)regionSize,
taskIndex);
});
return true;
}
FINLINE FLMBOOL FTKAPI testParam(
const char * pszParamName)
{
if( findParam( pszParamName))
{
return( TRUE);
}
return( FALSE);
}
//-----------------------------------------------------------------------------
// 描述: 根据名称返回对应的参数对象，若无则返回NULL
//-----------------------------------------------------------------------------
DbParam* DbParamList::paramByName(const string& name)
{
DbParam *result = findParam(name);
if (!result)
{
result = createParam(name, 0);
items_.add(result);
}
return result;
}
//-----------------------------------------------------------------------------
// 描述: 根据序号(1-based)返回对应的参数对象，若无则返回NULL
//-----------------------------------------------------------------------------
DbParam* DbParamList::paramByNumber(int number)
{
DbParam *result = findParam(number);
if (!result)
{
result = createParam("", number);
items_.add(result);
}
return result;
}
bool PluginManagerPrivate::create(pluginInfo &info)
{
if (info.plugin)
return true;
string param;
string descr;
const char *short_name = info.name;
for (; *short_name; short_name++){
char c = *short_name;
if ((c >= '0') && (c <= '9')) continue;
break;
}
string value;
param = "--enable-";
param += short_name;
if (findParam(param.c_str(), NULL, &value)){
info.bDisabled = false;
info.bFromCfg = true;
}
param = "--disable-";
param += short_name;
if (findParam(param.c_str(), NULL, &value)){
info.bDisabled = true;
info.bFromCfg = true;
}
if (info.bDisabled)
return false;
load(info);
if (info.info == NULL)
return false;
if (m_bInInit && (info.info->flags & (PLUGIN_PROTOCOL & ~PLUGIN_NOLOAD_DEFAULT))){
info.bDisabled = true;
release(info);
return false;
}
return createPlugin(info);
}
void parseCommandLine(int argc, wchar_t *argv[]) {
for (int i = 1; i < argc; i++) {
wchar_t * v = argv[i];
if (v[0] == '-') {
const wchar_t * value = v;
CmdLineParamDef * param = findParam(value);
if (!param) {
fatalError(std::wstring(L"Unknown command line parameter ") + v, 1);
}
if (param->paramType != NO_PARAMS) {
if (!value[0]) {
if (i == argc - 1) {
fatalError(std::wstring(L"Value not specified for parameter ") + v, 1);
}
i++;
value = argv[i];
}
}
else {
if (value[0]) {
fatalError(std::wstring(L"Value not allowed for parameter ") + v, 1);
}
}
if (param->handler) {
param->handler(param, value);
} else {
defParamHandler(param, value);
}
}
else {
nonParamHandler(v);
}
}
// handle logging
if (!params.logFile.empty()) {
CRLog::log_level level = CRLog::LL_INFO;
if (params.logLevel == L"FATAL")
level = CRLog::LL_FATAL;
else if (params.logLevel == L"ERROR")
level = CRLog::LL_ERROR;
else if (params.logLevel == L"DEBUG")
level = CRLog::LL_DEBUG;
else if (params.logLevel == L"TRACE")
level = CRLog::LL_TRACE;
CRLog::setFileLogger(toUtf8(params.logFile).c_str(), true);
CRLog::setLogLevel(level);
}
params.dumpParams();
}
int processArgs(int argc, char *argv[])
{
searchpath = argv[1];
SearchFiles = argc < 3 ? false : argv[2][0] != '-';
if (SearchFiles)
{
extensions = argv[2];
}
else
{
}
const char *param;
{
param = findParam("-mode", argc, argv);
if (param == NULL)
{
const char *program_name = strrchr(argv[0], DIRSEP) + 1;
if (memcmp(program_name, "tounix", 6) == 0)
Mode = MODE_UNIX;
else if (memcmp(program_name, "todos", 5) == 0)
Mode = MODE_DOS;
else if (memcmp(program_name, "tomac", 5) == 0)
Mode = MODE_MAC;
else
return error("mode not specified");
}
else if (strcmp(param, "unix") == 0)
Mode = MODE_UNIX;
else if (strcmp(param, "dos") == 0)
Mode = MODE_DOS;
else if (strcmp(param, "mac") == 0)
Mode = MODE_MAC;
else
return error("unknown mode");
}
SkipErrors = findFlag("-skiperrors", argc, argv);
ShowLogs = !findFlag("-nolog", argc, argv);
return 0;
}
static int changeParam(int X,int Y)
{ int n,ch;
char txt[50];
static char fName[100]="";
double x;
int pos;
for(n=0,ch=0,pos=1;n>=-1;)
{ n=findParam(X-1,Y,1,0,nModelVars,"Change Parameter",&pos);
if(pos==1)
{ FILE *f;
struct stat buf;
if(!findCalcHEPfile(fName)) continue;
if(stat(fName,&buf) || !(S_ISREG(buf.st_mode)) ) { messanykey(10,17, "Not a regular file"); continue; }
f=fopen(fName,"r");
if(f==NULL) { messanykey(10,17, "Can not open file"); continue; }
for(;;)
{ char name[20];
char txt[40];
double val;
int i;
if(fscanf(f,"%s",name)!=1) break;
if(name[0]=='#') { fscanf(f,"%*[^\n]"); continue;}
for(i=0;i<nModelVars;i++) if(strcmp(name,varNames[i])==0) break;
if(i==nModelVars)
{
sprintf(txt,"'%s' - unknown variable",name);
messanykey(10,10,txt);
}
if(fscanf(f,"%lf",&val)!=1)
{ sprintf(txt," wrong defined number for '%s'",name);
messanykey(10,10,txt);
} else if(i<nModelVars) { varValues[i]=val; ch=1;}
fscanf(f,"%*[^\n]");
}
fclose(f);
}else if(n>=0)
{ x=varValues[n];
sprintf(txt,"%s = ",varNames[n]);
if(correctDouble(20,20,txt,&x,1)) { varValues[n]=x; ch=1; }
}
}
return ch;
}
void printMasses(FILE * f,int sort)
{
if(f==NULL) return;
fprintf(f,"\nMasses of SuperParticles:\n");
{ int i,col;
int *n=malloc(sizeof(int)*Nodd);
int *nn=malloc(sizeof(int)*Nodd);
double * mass=malloc(sizeof(double)*Nodd);
int pow;
for(pow=0,i=0; i<Nodd; i++)
{ int err;
double v=findParam(OddPrtcls[i].mass,&err);
if(err==0) mass[i]=fabs(v); else mass[i]=-1;
n[pow]=i;
nn[pow]=i;
pow++;
}
if(pow>1)
for(i=0;i<pow-1;)
{ int i1=i+1;
if( mass[n[i]] > mass[n[i1]])
{ int k=n[i]; n[i]=n[i1]; n[i1]=k;
if(i==0) i++; else i--;
} else i++;
}
for(col=0,i=0;i<pow;i++)
{ int k;
if(sort)k=n[i];else k=nn[i];
fprintf(f,"%-3.3s : %-6.6s= %7.1f ", OddPrtcls[k].name,
OddPrtcls[k].mass,mass[k]);
col++;
if(f)
{ if(col==1 || col==2) fprintf(f,"|| ");
if(col==3) { col=0; fprintf(f,"\n");}
}
}
fprintf(f,"\n");
free(n); free(nn); free(mass);
}
}
void *PluginManagerPrivate::processEvent(Event *e)
{
CmdParam *p;
#ifndef WIN32
ExecParam *exec;
#endif
switch (e->type()){
case EventArg:
p = (CmdParam*)(e->param());
return (void*)findParam(p->arg, p->descr, p->value);
case EventPluginGetInfo:
return getInfo((unsigned)(e->param()));
case EventApplyPlugin:
return (void*)setInfo((const char*)(e->param()));
case EventPluginsUnload:
release_all((Plugin*)(e->param()));
return e->param();
case EventPluginsLoad:
load_all((Plugin*)(e->param()));
return e->param();
case EventUnloadPlugin:
release((const char*)(e->param()));
return e->param();
case EventLoadPlugin:
load((const char*)(e->param()));
return e->param();
case EventSaveState:
saveState();
break;
case EventGetPluginInfo:
return getInfo((const char*)(e->param()));
case EventArgc:
return (void*)(m_argc);
case EventArgv:
return (void*)(m_argv);
#ifndef WIN32
case EventExec:
exec = (ExecParam*)(e->param());
execute(exec->cmd, exec->arg);
return e->param();
#endif
default:
break;
}
return NULL;
}
void
QgarArgs::setParamValue(char* aFlag, char* aVal)
{
string tmp("-");
tmp += aFlag;
QgarParam* pParam = findParam(tmp.c_str());
if (pParam == 0)
{
ostringstream os;
os << "Unknown flag: "
<< aFlag;
throw QgarErrorUser(__FILE__, __LINE__,
"void qgar::QgarArgs::setParamValue(char*, char*)",
os.str());
}
pParam->setNewValue(aVal);
}
bool ParamCallbacks::
getParam(wbc_msgs::GetParameter::Request & request,
wbc_msgs::GetParameter::Response & response)
{
Status status;
Parameter const * param(findParam(request.com_type,
request.com_name,
request.param_name,
status.errstr));
if ( ! param) {
status.ok = false;
// status.errstr set by findParam...
return true;
}
if ( ! param_to_msg(param, response.param)) {
status.ok = false;
status.errstr = "parameter conversion error (probably a bug!)";
return true;
}
response.ok = true;
return true;
}
//! Allocate storage and populate the volume.
void AMRVolume::commit()
{
updateEditableParameters();
// Make the voxel value range visible to the application.
if (findParam("voxelRange") == nullptr)
setParam("voxelRange", voxelRange);
else
voxelRange = getParam2f("voxelRange", voxelRange);
auto methodStringFromEnv =
utility::getEnvVar<std::string>("OSPRAY_AMR_METHOD");
std::string methodString =
methodStringFromEnv.value_or(getParamString("amrMethod","current"));
if (methodString == "finest" || methodString == "finestLevel")
ispc::AMR_install_finest(getIE());
else if (methodString == "current" || methodString == "currentLevel")
ispc::AMR_install_current(getIE());
else if (methodString == "octant")
ispc::AMR_install_octant(getIE());
if (data != nullptr) //TODO: support data updates
return;
brickInfoData = getParamData("brickInfo");
assert(brickInfoData);
assert(brickInfoData->data);
brickDataData = getParamData("brickData");
assert(brickDataData);
assert(brickDataData->data);
data = make_unique<amr::AMRData>(*brickInfoData,*brickDataData);
accel = make_unique<amr::AMRAccel>(*data);
// finding coarset cell size + finest level cell width
float coarsestCellWidth = 0.f;
float finestLevelCellWidth = data->brick[0].cellWidth;
box3i rootLevelBox = empty;
for (auto &b : data->brick) {
if (b.level == 0)
rootLevelBox.extend(b.box);
finestLevelCellWidth = min(finestLevelCellWidth, b.cellWidth);
coarsestCellWidth = max(coarsestCellWidth, b.cellWidth);
}
vec3i rootGridDims = rootLevelBox.size() + vec3i(1);
ospLogF(1) << "found root level dimensions of " << rootGridDims;
ospLogF(1) << "coarsest cell width is " << coarsestCellWidth << std::endl;
auto rateFromEnv =
utility::getEnvVar<float>("OSPRAY_AMR_SAMPLING_STEP");
float samplingStep = rateFromEnv.value_or(0.1f * coarsestCellWidth);
box3f worldBounds = accel->worldBounds;
const vec3f gridSpacing = getParam3f("gridSpacing", vec3f(1.f));
const vec3f gridOrigin = getParam3f("gridOrigin", vec3f(0.f));
voxelType = getParamString("voxelType", "unspecified");
auto voxelTypeID = getVoxelType();
switch (voxelTypeID) {
case OSP_UCHAR:
break;
case OSP_SHORT:
break;
case OSP_USHORT:
break;
case OSP_FLOAT:
break;
case OSP_DOUBLE:
break;
default:
throw std::runtime_error("amrVolume unsupported voxel type '"
+ voxelType + "'");
}
ispc::AMRVolume_set(getIE(), (ispc::box3f&)worldBounds, samplingStep,
(const ispc::vec3f&)gridOrigin,
(const ispc::vec3f&)gridSpacing);
ispc::AMRVolume_setAMR(getIE(),
accel->node.size(),
&accel->node[0],
accel->leaf.size(),
&accel->leaf[0],
accel->level.size(),
&accel->level[0],
voxelTypeID,
(ispc::box3f &)worldBounds);
tasking::parallel_for(accel->leaf.size(),[&](size_t leafID) {
ispc::AMRVolume_computeValueRangeOfLeaf(getIE(), leafID);
});
}
static void show_dependence(int X, int Y)
{ void *pscr1=NULL;
int i,mPos=1;
REAL mem;
int nc,ni,pos1,pos2;
char txt[50];
for(pos1=1;;)
{ nc=findParam(X-1,Y,0,nModelVars,nModelFunc,"Constraint",&pos1);
if(!pos1) return;
for(pos2=1;;)
{ double xMin,xMax;
int nPoints=100;
sprintf(txt,"check \"%s\" depends on",varNames[nc]);
ni=findParam(X-1,Y,0,0,nModelVars,txt,&pos2);
mem=varValues[ni];
if(ni<0) break;
xMin=varValues[ni] - fabs(varValues[ni] )/10;
xMax=varValues[ni] + fabs(varValues[ni] )/10;
for(;;)
{ int k3=0;
char strmen[]="\026 "
" x-Min = XXX "
" x-Max = YYY "
" Npoints = NNN "
" Display ";
improveStr(strmen,"XXX","%G",xMin);
improveStr(strmen,"YYY","%G",xMax);
improveStr(strmen,"NNN","%d",nPoints);
sprintf(txt,"check %s(%s)",varNames[nc],varNames[ni]);
menu1(X,Y+2,txt,strmen,"",NULL,&k3);
if(!k3) break;
switch(k3)
{ case 1: correctDouble(X,Y+12,"xMin = ",&xMin,1); break;
case 2: correctDouble(X,Y+12,"xMax = ",&xMax,1); break;
case 3: correctInt(X,Y+12,"nPoints = ",&nPoints,1); break;
case 4:
if( xMax>xMin && nPoints>=3 && nPoints<=150)
{ double dx=(xMax-xMin)/(nPoints-1);
double f[150];
int i, NaN=0,Esc=0;
informline(0,nPoints);
for(i=0;i<nPoints;i++)
{ double x=xMin+i*dx;
varValues[ni]=x;
NaN=calcMainFunc();
if(NaN)
{ char mess[100];
sprintf(mess,"Can not evaluate constraints for %s=%G",varNames[ni], x);
messanykey(16,5,mess);
break;
}
f[i]=varValues[nc];
Esc=informline(i,nPoints);
if(Esc) break;
}
varValues[ni]=mem;
calcMainFunc();
if(!(NaN||Esc)) plot_1(xMin,xMax,nPoints,f,NULL,"Plot",
varNames[ni], varNames[nc]);
} else messanykey(16,5," Correct input is \n"
" xMin<xMax,\n"
" 3<=nPoints<=150");
break;
}
}
}
}
}
int main(int argc, char** argv)
{
try
{
CIMClient client;
client.connectLocal();
// Define instance name:
CIMObjectPath instanceName("Methods.key=7777");
// Define input arguments:
Array<CIMParamValue> in;
Array<CIMParamValue> out;
// Invoke the method:
const String NAMESPACE = "root/cimv2";
const String methodName = "foo5";
Uint32 in_arg = 234567;
Uint32 in_out_arg = 123456;
in.append(CIMParamValue("in_arg", in_arg));
in.append(CIMParamValue("in_out_arg", in_out_arg));
CIMValue value = client.invokeMethod(
NAMESPACE,
instanceName,
methodName,
in,
out);
{
assert(value.getType() == CIMTYPE_UINT32);
Uint32 t;
value.get(t);
assert(t == 1200);
}
// Check output argument:
assert(out.size() == 2);
{
Uint32 pos = 0;
assert((pos = findParam(out, "in_out_arg")) != -1);
assert(out[pos].getParameterName() == "in_out_arg");
CIMValue value = out[0].getValue();
Uint32 in_out_arg_rtn;
value.get(in_out_arg_rtn);
assert(in_out_arg_rtn == in_out_arg);
assert((pos = findParam(out, "out_arg")) != -1);
assert(out[pos].getParameterName() == "out_arg");
CIMValue value1 = out[1].getValue();
Uint32 out_arg_rtn;
value1.get(out_arg_rtn);
assert(out_arg_rtn == in_arg);
}
}
catch(Exception& e)
{
PEGASUS_STD(cerr) << "Error: " << e.getMessage() << PEGASUS_STD(endl);
exit(1);
}
PEGASUS_STD(cout) << "+++++ passed all tests" << PEGASUS_STD(endl);
return 0;
}
//------------------------------------------------------------------------------
double tracker::runGridSearch(IplImage* gray, int size, int flag, double* d,
double* e, double* varianceImage, double* integralImage, int anchor)
{
double v = 0, dimension = 0;
int dimensionFloor = 0;
IplImage* grayNew = 0;
double* feature = 0;
double* feature1 = 0;
double slLimitUp = 1.1;
double tlLimidUp = -4;
double slLimitLw = .9;
double tlLimidLw = 4;
double num = (GRID_SIDE_SIZE-1);
if(flag == 1)
dimension = (double)(gray->width)*(double)((double)size/(double)gray->height);
else
dimension=(double)(gray->height)*(double)((double)size/(double)gray->width);
dimensionFloor = floor(dimension);
if(flag == 1)
grayNew = cvCreateImage(cvSize(dimensionFloor,size), 8, 1);
else
grayNew = cvCreateImage(cvSize(size,dimensionFloor), 8, 1);
cvResize(gray, grayNew, CV_INTER_LINEAR);
feature = calculateFeature(grayNew, flag, 0);
feature1 = calculateFeature(grayNew, flag, 1);
double scaleFactor = slLimitUp;
double translateFactor = tlLimidUp;
double updatedScaleFactor = scaleFactor;
double updatedTranslateFactor = tlLimidUp;
double scale=(slLimitUp-slLimitLw)/num;
double translate=(tlLimidLw-tlLimidUp)/num;
for(int l = 0; l < 6; l++)
{
v = findParam(scaleFactor, translateFactor, &updatedScaleFactor,
&updatedTranslateFactor, feature, feature1, varianceImage, integralImage,
size, scale, translate, anchor);
scale /= 2;
translate /= 2;
scaleFactor = updatedScaleFactor + (num/2)*scale;
translateFactor = updatedTranslateFactor - (num/2)*translate;
if(translateFactor <= tlLimidUp) translateFactor = tlLimidUp;
if(scaleFactor >= slLimitUp) scaleFactor = slLimitUp;
if((scaleFactor - num*scale) <= slLimitLw)
scaleFactor = slLimitLw + (num*scale);
if((translateFactor+num*translate) >= tlLimidLw)
translateFactor = tlLimidLw - (num*translate);
}
*d = scaleFactor;
*e = translateFactor;
cvReleaseImage(&grayNew);
delete [] feature;
return v;
}
void
QgarArgs::analyzeLine(int argc, char * argv[])
{
int i = 1;
while (i < argc)
{
QgarParam* pParam = findParam(argv[i]);
// If the parameter is not recognized, try flags -h and -gui
if (!pParam)
{
if (!strcmp("-h", argv[i]))
{
_exit = true;
showUsage(argv[0]);
}
else
{
if (!strcmp("-gui", argv[i]))
{
_exit = true;
printGUI();
}
else
{
if (!strcmp("-interact", argv[i]))
{
_interactive = true;
}
else
{
_error = true;
cerr << "QGAR: ERROR NOTIFIED BY AN APPLICATION" << endl
<< ">>> Bad flag: " << argv[i] << endl;
}
}
}
return;
}
switch (pParam->paramStatus())
{
// --------------------------------------------------------
case SINGLEFLAG:
pParam->setUseFlag();
break;
// --------------------------------------------------------
case REQPARAM:
case OPTPARAM:
++i;
if (i == argc)
{
_error = true;
cerr << "QGAR: ERROR NOTIFIED BY AN APPLICATION" << endl
<< ">>> No value for flag " << argv[i-1] << endl;
return;
}
if (findParam(argv[i]))
{
_error = true;
cerr << "QGAR: ERROR NOTIFIED BY AN APPLICATION" << endl
<< ">>> Bad value for flag " << argv[i - 1] << ": "
<< argv[i] << endl;
return;
}
pParam->setValue(argv[i]);
pParam->setUseFlag();
break;
// --------------------------------------------------------
case REQMULTIPARAM:
case OPTMULTIPARAM:
++i;
if (i == argc)
{
_error = true;
cerr << "QGAR: ERROR NOTIFIED BY AN APPLICATION" << endl
<< ">>> No value for flag " << argv[i-1] << endl;
return;
}
if (findParam(argv[i]))
{
_error = true;
cerr << "QGAR: ERROR NOTIFIED BY AN APPLICATION" << endl
<< ">>> Bad value for flag " << argv[i - 1] << ": "
<< argv[i] << endl;
return;
}
do
{
pParam->addArgument(argv[i]);
++i;
}
while ((i < argc) && (findParam(argv[i])));
pParam->setUseFlag();
--i;
break;
// --------------------------------------------------------
} // END switch
// Next argument
++i;
} // END while
// All the arguments are processed
// Check required parameters
for (list<QgarParam*>::iterator it = _args.begin();
it != _args.end();
++it)
{
if ((((*it)->paramStatus() == REQPARAM) || ((*it)->paramStatus() == REQMULTIPARAM))
&& !((*it)->useFlag()))
{
_error = true;
cerr << "QGAR: ERROR NOTIFIED BY AN APPLICATION" << endl
<< ">>> Missing flag: " << (*it)->name() << endl;
return;
}
}
}
bool ParamCallbacks::
openChannel(wbc_msgs::OpenChannel::Request & request,
wbc_msgs::OpenChannel::Response & response)
{
response.param_type = OpspaceParameter::PARAMETER_TYPE_VOID;
Parameter * param(findParam(request.com_type,
request.com_name,
request.param_name,
response.errstr));
if ( ! param) {
response.ok = false;
// status.errstr set by findParam...
return true;
}
switch (param->type_) {
case PARAMETER_TYPE_STRING:
if (( ! param->getString())
|| ( ! dynamic_cast<StringParameter*>(param))) {
response.ok = false;
response.errstr = "buggy string parameter (oops!)";
return true;
}
else {
StringChannel msg;
msg.channel_id = next_channel_id_++;
msg.transaction_id = 0;
msg.value = *param->getString();
response.ok = true;
response.string_channel.push_back(msg);
strings_.insert(make_pair(msg.channel_id, dynamic_cast<StringParameter*>(param)));
return true;
}
case PARAMETER_TYPE_INTEGER:
if (( ! param->getInteger())
|| ( ! dynamic_cast<IntegerParameter*>(param))) {
response.ok = false;
response.errstr = "buggy integer parameter (oops!)";
return true;
}
else {
IntegerChannel msg;
msg.channel_id = next_channel_id_++;
msg.transaction_id = 0;
msg.value = *param->getInteger();
response.ok = true;
response.integer_channel.push_back(msg);
integers_.insert(make_pair(msg.channel_id, dynamic_cast<IntegerParameter*>(param)));
return true;
}
case PARAMETER_TYPE_REAL:
if (( ! param->getReal())
|| ( ! dynamic_cast<RealParameter*>(param))) {
response.ok = false;
response.errstr = "buggy real parameter (oops!)";
return true;
}
else {
RealChannel msg;
msg.channel_id = next_channel_id_++;
msg.transaction_id = 0;
msg.value = *param->getReal();
response.ok = true;
response.real_channel.push_back(msg);
reals_.insert(make_pair(msg.channel_id, dynamic_cast<RealParameter*>(param)));
return true;
}
case PARAMETER_TYPE_VECTOR:
if (( ! param->getVector())
|| ( ! dynamic_cast<VectorParameter*>(param))) {
response.ok = false;
response.errstr = "buggy vector parameter (oops!)";
return true;
}
else {
VectorChannel msg;
msg.channel_id = next_channel_id_++;
msg.transaction_id = 0;
Vector const * vv(param->getVector());
msg.value.resize(vv->rows());
Vector::Map(&msg.value[0], vv->rows()) = *vv;
response.ok = true;
response.vector_channel.push_back(msg);
vectors_.insert(make_pair(msg.channel_id, dynamic_cast<VectorParameter*>(param)));
return true;
}
case PARAMETER_TYPE_MATRIX:
if (( ! param->getMatrix())
|| ( ! dynamic_cast<MatrixParameter*>(param))) {
response.ok = false;
response.errstr = "buggy matrix parameter (oops!)";
return true;
}
else {
MatrixChannel msg;
msg.channel_id = next_channel_id_++;
msg.transaction_id = 0;
Matrix const * mm(param->getMatrix());
msg.value.resize(mm->rows() * mm->cols());
msg.nrows = mm->rows();
msg.ncols = mm->cols();
Matrix::Map(&msg.value[0], mm->rows(), mm->cols()) = *mm;
response.ok = true;
response.matrix_channel.push_back(msg);
matrices_.insert(make_pair(msg.channel_id, dynamic_cast<MatrixParameter*>(param)));
return true;
}
// default:
}
response.ok = false;
response.errstr = "buggy parameter type handling (oops!)";
return true;
}
bool ParamCallbacks::
setParam(wbc_msgs::SetParameter::Request & request,
wbc_msgs::SetParameter::Response & response)
{
Status status;
Parameter * param(findParam(request.com_type,
request.com_name,
request.param.name,
status.errstr));
if ( ! param) {
status.ok = false;
// status.errstr set by findParam...
return true;
}
switch (request.param.type) {
case OpspaceParameter::PARAMETER_TYPE_STRING:
status = param->set(request.param.strval);
break;
case OpspaceParameter::PARAMETER_TYPE_INTEGER:
// grr, one day the 32 vs 64 bit thing will bite us
status = param->set((int) request.param.intval);
break;
case OpspaceParameter::PARAMETER_TYPE_REAL:
if (1 != request.param.realval.size()) {
status.ok = false;
status.errstr = "expected exactly one realval";
}
else {
status = param->set(request.param.realval[0]);
}
break;
case OpspaceParameter::PARAMETER_TYPE_VECTOR:
{
// I tried to find a more or less elegant and non-intrusive
// way to do without the tmp, and failed. Eigen is simply not
// made to mix well with runtime dynamic typing. For instance,
// Eigen::Map<> can be made to look "just like"
// Eigen::Matrix<> to the compiler in expressions, but trying
// to pass a const ref to a map in some place which expects a
// const ref to a vector simply does not work.
Vector tmp(jspace::Vector::Map(&request.param.realval[0],
request.param.realval.size()));
status = param->set(tmp);
}
break;
case OpspaceParameter::PARAMETER_TYPE_MATRIX:
if ((0 > request.param.nrows) || (0 > request.param.ncols)) {
status.ok = false;
status.errstr = "invalid matrix dimensions";
}
else if (request.param.realval.size() != request.param.nrows * request.param.ncols) {
status.ok = false;
status.errstr = "matrix dimension mismatch";
}
else {
// See comments about Eigen::Map<> above.
Matrix tmp(jspace::Vector::Map(&request.param.realval[0],
request.param.nrows,
request.param.ncols));
status = param->set(tmp);
}
break;
default:
status.ok = false;
status.errstr = "unsupported or invalid type";
}
response.ok = status.ok;
response.errstr = status.errstr;
return true;
}
bool HevcParameterSets::findParam32(uint32_t key, uint32_t *param) {
return findParam(key, param, mParams);
}
/*
* State machine for machester encoding.
* Achieve wave phase.
*/
void encode_machine(void)
{
state_t sta = enc.state;
switch(sta){
case Waiting:
if( 0 == ticker % 2){
dbg_led = 0;
if( uartGetAmount() ){
enc.data = uartGetChar();
enc.byte_rev = 1;
HIJACK_CompareConfig(hijackOutputModeSet); //next is 0x00, falling
enc_odd = 0;
}
else{
HIJACK_CompareConfig(hijackOutputModeClear); //next is 0x80, rising
enc.byte_rev = 0;
}
}
else{
if(enc.byte_rev){//new byte
HIJACK_CompareConfig(hijackOutputModeClear); //falling
enc.state = Sta0; //state switch
}
else{ //no byte
HIJACK_CompareConfig(hijackOutputModeSet); //rising, keep in waiting state
}
}
break;
//
case Sta0: //prepare for sta1, rising edge
findParam(BIT0, Bit0);
break;
//
case Sta1: //prepare for sta2, falling edge
if( 0 == ticker % 2){
HIJACK_CompareConfig(hijackOutputModeSet); //next is 0x00, for falling
}
else{
HIJACK_CompareConfig(hijackOutputModeClear); //falling
enc.state = Sta2; //state switch
}
break;
//
case Sta2: //prepare for sta3, rising edge
if( 0 == ticker % 2){
HIJACK_CompareConfig(hijackOutputModeClear); //next is 0x80, for rising
}
else{
HIJACK_CompareConfig(hijackOutputModeSet); //rising
enc.state = Sta3; //state switch
}
break;
//
case Sta3: //prepare for bit7
findParam(BIT7, Bit7);
break;
//
case Bit0: //prepare for Bit1
findParam(BIT1, Bit1);
break;
//
case Bit1: //prepare for Bit2
findParam(BIT2, Bit2);
break;
//
case Bit2: //prepare for Bit3
findParam(BIT3, Bit3);
break;
//
case Bit3: //prepare for Bit4
findParam(BIT4, Bit4);
break;
//
case Bit4: //prepare for Bit5
findParam(BIT5, Bit5);
break;
//
case Bit5: //prepare for Bit6
findParam(BIT6, Bit6);
break;
//
case Bit6: //prepare for Bit7
findParam(BIT7, Bit7);
break;
//
case Bit7: //prepare for parity
if( 0 == ticker % 2){
if( 0 == ( enc_odd%2 ) ){//there is even 1(s), output 1
enc.edge = rising;
HIJACK_CompareConfig(hijackOutputModeClear); //next is 0x80, for rising
dbg_led = 1;
}
else{//there is odd 1(s), output 0
enc.edge = falling;
HIJACK_CompareConfig(hijackOutputModeSet); //next is 0x00, for falling
dbg_led = 0;
}
}
else{
if( rising == enc.edge ){
HIJACK_CompareConfig(hijackOutputModeSet); //rising
}
else{
HIJACK_CompareConfig(hijackOutputModeClear); //falling
}
enc.state = Parity; //state switch
}
break;
//
case Parity://prepare for stop bit, it is always 1
if( 0 == ticker % 2){
HIJACK_CompareConfig(hijackOutputModeClear); //next is 0x80, for rising
dbg_led = 0 ;
}
else{
HIJACK_CompareConfig(hijackOutputModeSet); //rising
enc.state = Sto0; //state switch
}
break;
//
case Sto0: //back to waiting
if( 0 == ticker % 2){
HIJACK_CompareConfig(hijackOutputModeClear); //next is 0x80, for rising
}
else{
HIJACK_CompareConfig(hijackOutputModeSet); //rising
enc.state = Waiting; //state switch
}
break;
//
#if 0
case Sto1: //go to waiting mode
enc.state = Waiting;
break;
//
#endif
default:
break;
//
}
}
int main(int argc, char* argv[])
{
#if defined _DEBUG
printf("+++ start\n");
int argi=0;
printf("+++ argc: %d\n", argc);
for ( argi; argi<argc; argi++)
{
printf("+++ argv[%d]='%s'\n", argi, argv[argi]);
}
#endif
if ( argc>1 )
{
if ( findParam(argv, argc, "-h")>0 ||
findParam(argv, argc, "--help")>0
)
{
help(argv[0]);
return RET_SUCCES;
}
}
else
{
printf("error: not enought params\n");
help(argv[0]);
return RET_ERR_PARAMS;
}
bfo=0;
if ( findParam(argv, argc, "-d")>0 ||
findParam(argv, argc, "--debug")>0
)
{
bfo |= BFO_DEBUG;
#if defined _DEBUG
printf("+++ main: in debug BF mode: bfo: 0x%X\n", bfo);
#endif
}
bf_mem=(UCHAR*)calloc(BF_MEMORY_SIZE, sizeof(char));
if ( !bf_mem )
{
#if defined _DEBUG
printf("--- main: bf_mem=NULL\n");
#else
printf("error: can't allocate memory for BF cells\n");
#endif
return RET_ERR_MEM;
}
FILE* bf_sc_fd;
if ( argc>1 && strEndsWith(argv[argc-1], "bf") )
{
bf_sc_fd=fopen(argv[argc-1], "r");
if ( bf_sc_fd )
{
bf_sc=(UCHAR*)calloc(BUFFER_SIZE, sizeof(char));
int bf_sc_sz=0;
int readb=0;
while( !feof(bf_sc_fd) )
{
if ( bf_sc )
{
readb=fread(bf_sc+bf_sc_sz*BUFFER_SIZE*sizeof(char),
BUFFER_SIZE*sizeof(char),
1,
bf_sc_fd);
// #if defined _DEBUG
// printf("bf_sc::fread #%d:\n%s (%d)\n", bf_sc_sz+1, bf_sc, readb);
// #endif
if ( readb==1 )
{
bf_sc_sz+=1;
bf_sc=(UCHAR*)realloc(bf_sc,
(bf_sc_sz+1)*BUFFER_SIZE*sizeof(char));
memset(bf_sc+(BUFFER_SIZE*bf_sc_sz), 0, BUFFER_SIZE);
}
}
else
{
#if defined _DEBUG
printf("--- bf_sc=NULL\n");
#endif
return RET_ERR_MEM;
}
}
close(bf_sc_fd);
if ( bf_sc )
{
#if defined _DEBUG
printf("bf_sc @ 0x%X (%d):\n'%s'\n", bf_sc,
BUFFER_SIZE*(bf_sc_sz+1)*sizeof(char),
bf_sc);
#endif
if ( strEndsWith(argv[argc-1], ".qbf") ||
findParam(argv, argc, "-q")>0 ||
findParam(argv, argc, "--quick")>0
)
{
bfo |= BFO_QUICK;
#if defined _DEBUG
printf("+++ main: in quick BF mode: bfo: 0x%X\n", bfo);
#endif
#if defined _DEBUG
printf("+++ main: prepare sc\n");
#endif
bf_sc=prepare(bf_sc);
if ( bf_sc )
{
#if defined _DEBUG
printf("bf_sc @ 0x%X (%d):\n'%s'\n", bf_sc,
BUFFER_SIZE*(bf_sc_sz+1)*sizeof(char),
bf_sc);
#endif
}
else
{
#if defined _DEBUG
printf("--- main: can't prepare SC\n");
#endif
return RET_ERR_SC;
}
}
}
if ( findParam(argv, argc, "-sc")>0 ||
findParam(argv, argc, "--show-code")>0
)
{
printf("Source code:\n'%s'\n", bf_sc);
}
if ( bf_sc )
{
int sz=strlen(bf_sc);
#if defined _DEBUG
printf("+++ bf_sc[%d]=0x%02X\n", sz-1, bf_sc[sz-1]);
#endif
// TODO: str replace ?
if ( bf_sc[sz-1]==0x0a || bf_sc[sz-1]==0x0d )
bf_sc[sz-1]=0;
if ( bf_sc[sz-2]==0x0a || bf_sc[sz-2]==0x0a )
bf_sc[sz-2]=0;
if ( validate(bf_sc) )
{
bf_mp=bf_mem;
execute(bf_sc);
printf("\n");
free(bf_sc);
free(bf_mem);
}
else
{
printf("code is invalid\n");
}
}
}
else
{
printf("can't open '%s'\n", argv[argc-1]);
}
}
else
{
printf("'%s' seems to be not a BF source\n", argv[argc-1]);
}
#if defined _DEBUG
printf("+++ stop\n");
#endif
return RET_SUCCES;
};
