void CSettings::RegisterSettings(void)
{
SetModuleName("default");
m_Set_EnableAudio = FindSystemSettingId("Enable Audio");
m_Set_FixedAudio = FindSystemSettingId("Fixed Audio");
m_Set_SyncAudio = FindSystemSettingId("Sync Audio");
m_Set_FullSpeed = FindSystemSettingId("Full Speed");
m_Set_LimitFPS = FindSystemSettingId("Limit FPS");
m_Set_basic_mode = FindSystemSettingId("Basic Mode");
m_Set_debugger = FindSystemSettingId("Debugger");
m_Set_log_flush = FindSystemSettingId("Log Auto Flush");
m_Set_log_dir = FindSystemSettingId("Dir:Log");
SetModuleName("Audio");
RegisterSetting(Set_Volume, Data_DWORD_General, "Volume", "Settings", 100, NULL);
RegisterSetting(Set_Logging_MD5, Data_DWORD_General, "MD5", "Logging", g_ModuleLogLevel[TraceMD5], NULL);
RegisterSetting(Set_Logging_Thread, Data_DWORD_General, "Thread", "Logging", g_ModuleLogLevel[TraceThread], NULL);
RegisterSetting(Set_Logging_Path, Data_DWORD_General, "Path", "Logging", g_ModuleLogLevel[TracePath], NULL);
RegisterSetting(Set_Logging_InitShutdown, Data_DWORD_General, "InitShutdown", "Logging", g_ModuleLogLevel[TraceAudioInitShutdown], NULL);
RegisterSetting(Set_Logging_Interface, Data_DWORD_General, "Interface", "Logging", g_ModuleLogLevel[TraceAudioInterface], NULL);
RegisterSetting(Set_Logging_Driver, Data_DWORD_General, "Driver", "Logging", g_ModuleLogLevel[TraceAudioDriver], NULL);
RegisterSetting(Set_TinyBuffer, Data_DWORD_Game, "TinyBuffer", "", (bool)true, NULL);
RegisterSetting(Set_FPSBuffer, Data_DWORD_Game, "FPSBuffer", "", (bool)true, NULL);
LogLevelChanged();
}
CvBlobTrackGenYML(): m_TrackList(sizeof(DefBlobTrack)) {
m_Frame = 0;
m_pFileName = NULL;
m_Size = cvSize(2, 2);
SetModuleName("YML");
};
CvBlobTrackAnalysisTrackDist(): m_Tracks(sizeof(DefTrackForDist)), m_TrackDataBase(sizeof(DefTrackForDist)) {
m_pDebugImg = 0;
//m_pDebugAVI = 0;
m_Frame = 0;
m_pTempData = NULL;
m_TempDataSize = 0;
m_pDebugAVIName = NULL;
AddParam("DebugAVI", &m_pDebugAVIName);
CommentParam("DebugAVI", "Name of AVI file to save images from debug window");
m_TraceLen = 50;
AddParam("TraceLen", &m_TraceLen);
CommentParam("TraceLen", "Length (in frames) of trajectory part that is used for comparison");
m_AbnormalThreshold = 0.02f;
AddParam("AbnormalThreshold", &m_AbnormalThreshold);
CommentParam("AbnormalThreshold", "If trajectory is equal with less then <AbnormalThreshold*DataBaseTrackNum> tracks then trajectory is abnormal");
m_PosThreshold = 1.25;
AddParam("PosThreshold", &m_PosThreshold);
CommentParam("PosThreshold", "Minimal allowd distance in blob width that is allowed");
m_VelThreshold = 0.5;
AddParam("VelThreshold", &m_VelThreshold);
CommentParam("VelThreshold", "Minimal allowed relative difference between blob speed");
SetModuleName("TrackDist");
} /* Constructor. */
void CActiveXUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
{
if( _tcscmp(pstrName, _T("clsid")) == 0 ) CreateControl(pstrValue);
else if( _tcscmp(pstrName, _T("modulename")) == 0 ) SetModuleName(pstrValue);
else if( _tcscmp(pstrName, _T("delaycreate")) == 0 ) SetDelayCreate(_tcscmp(pstrValue, _T("true")) == 0);
else CControlUI::SetAttribute(pstrName, pstrValue);
}
EarlabModuleInstance::EarlabModuleInstance(const char *ModuleFileName, const char *ParameterFileName, const char *ModuleName)
{
memset(this, 0, sizeof(EarlabModuleInstance));
MapToModule(ModuleFileName);
SetModuleName(ModuleName);
ReadParameters(ParameterFileName);
}
luna::Function * RandomFunction()
{
auto f = g_gc.NewFunction();
auto s = RandomString();
f->SetModuleName(s);
f->SetLine(RandomNum(1000));
int instruction_count = RandomRange(10, 1000);
for (int i = 0; i < instruction_count; ++i)
{
unsigned int op_min = luna::OpType_LoadNil;
unsigned int op_max = luna::OpType_GetGlobal;
luna::OpType op = static_cast<luna::OpType>(RandomRange(op_min, op_max));
luna::Instruction instruction(op, RandomNum(128), RandomNum(128), RandomNum(128));
f->AddInstruction(instruction, i);
}
int const_num = RandomNum(5);
for (int i = 0; i < const_num; ++i)
f->AddConstNumber(RandomNum(100000));
int const_str = RandomNum(5);
for (int i = 0; i < const_str; ++i)
f->AddConstString(RandomString());
CHECK_BARRIER(g_gc, f);
return f;
}
CvBlobTrackPredictKalman::CvBlobTrackPredictKalman()
{
m_ModelNoise = 1e-6f;
m_DataNoisePos = 1e-6f;
m_DataNoiseSize = 1e-1f;
#if STATE_NUM>6
m_DataNoiseSize *= (float)pow(20.,2.);
#else
m_DataNoiseSize /= (float)pow(20.,2.);
#endif
AddParam("ModelNoise",&m_ModelNoise);
AddParam("DataNoisePos",&m_DataNoisePos);
AddParam("DataNoiseSize",&m_DataNoiseSize);
m_Frame = 0;
m_pKalman = cvCreateKalman(STATE_NUM,4);
memcpy( m_pKalman->transition_matrix->data.fl, A, sizeof(A));
memcpy( m_pKalman->measurement_matrix->data.fl, H, sizeof(H));
cvSetIdentity( m_pKalman->process_noise_cov, cvRealScalar(m_ModelNoise) );
cvSetIdentity( m_pKalman->measurement_noise_cov, cvRealScalar(m_DataNoisePos) );
CV_MAT_ELEM(*m_pKalman->measurement_noise_cov, float, 2,2) = m_DataNoiseSize;
CV_MAT_ELEM(*m_pKalman->measurement_noise_cov, float, 3,3) = m_DataNoiseSize;
cvSetIdentity( m_pKalman->error_cov_post, cvRealScalar(1));
cvZero(m_pKalman->state_post);
cvZero(m_pKalman->state_pre);
SetModuleName("Kalman");
}
CvBlobTrackerCC():m_BlobList(sizeof(DefBlobTracker))
{
// m_LastID = 0;
m_ClearHyp = 0;
m_pMem = cvCreateMemStorage();
m_Collision = 1; /* if 1 then collistion will be detected and processed */
AddParam("Collision",&m_Collision);
CommentParam("Collision", "If 1 then collision cases are processed in special way");
m_AlphaSize = 0.02f;
AddParam("AlphaSize",&m_AlphaSize);
CommentParam("AlphaSize", "Size update speed (0..1)");
m_AlphaPos = 1.0f;
AddParam("AlphaPos",&m_AlphaPos);
CommentParam("AlphaPos", "Position update speed (0..1)");
m_Alpha = 0.001f;
AddParam("Alpha", &m_Alpha);
CommentParam("Alpha","Coefficient for model histogram updating (0 - hist is not updated)");
m_ConfidenceType=0;
m_ConfidenceTypeStr = "NearestBlob";
AddParam("ConfidenceType", &m_ConfidenceTypeStr);
CommentParam("ConfidenceType","Type of calculated Confidence (NearestBlob, AverFG, BC)");
SetModuleName("CC");
};
CvBlobTrackGen1(int BlobSizeNorm = 0):m_TrackList(sizeof(DefBlobTrack))
{
m_BlobSizeNorm = BlobSizeNorm;
m_Frame = 0;
m_pFileName = NULL;
SetModuleName("Gen1");
}
CvBlobTrackPostProcList(CvBlobTrackPostProcOne* (*create)()):m_BlobFilterList(sizeof(DefBlobFilter))
{
m_Frame = 0;
m_CreatePostProc = create;
CvBlobTrackPostProcOne* pM = create();
TransferParamsFromChild(pM,NULL);
pM->Release();
SetModuleName("List");
}
/* Constructor of BlobDetector: */
CvBlobDetectorSimple::CvBlobDetectorSimple()
{
int i = 0;
m_pMaskBlobNew = NULL;
m_pMaskBlobExist = NULL;
for(i=0;i<EBD_FRAME_NUM;++i)m_pBlobLists[i] = NULL;
SetModuleName("Simple");
}
/* Constructor for BlobDetector: */
CvBlobDetectorCC::CvBlobDetectorCC() :
#ifdef USE_OBJECT_DETECTOR
m_split_detector(0),
#endif
m_detected_blob_seq(sizeof(CvDetectedBlob)),
m_roi_seq(0),
m_debug_blob_seq(sizeof(CvDetectedBlob))
{
/*CvDrawShape shapes[] =
{
{ CvDrawShape::RECT, {{255,255,255}} },
{ CvDrawShape::RECT, {{0,0,255}} },
{ CvDrawShape::ELLIPSE, {{0,255,0}} }
};
int num_shapes = sizeof(shapes) / sizeof(shapes[0]);*/
int i = 0;
SEQ_SIZE = 10;
AddParam("Latency",&SEQ_SIZE);
for(i=0;i<SEQ_SIZE_MAX;++i)m_pBlobLists[i] = NULL;
for(i=0;i<SEQ_NUM;++i)m_TrackSeq[i].size = 0;
m_TrackNum = 0;
m_HMin = 0.02f;
m_WMin = 0.01f;
AddParam("HMin",&m_HMin);
AddParam("WMin",&m_WMin);
m_MinDistToBorder = 1.1f;
AddParam("MinDistToBorder",&m_MinDistToBorder);
CommentParam("MinDistToBorder","Minimal allowed distance from blob center to image border in blob sizes");
m_Clastering=1;
AddParam("Clastering",&m_Clastering);
CommentParam("Clastering","Minimal allowed distance from blob center to image border in blob sizes");
m_param_split_detector_file_name = 0;
#ifdef USE_OBJECT_DETECTOR
AddParam("Detector", &m_param_split_detector_file_name);
CommentParam("Detector", "Detector file name");
#endif
m_param_roi_scale = 1.5F;
AddParam("ROIScale", &m_param_roi_scale);
CommentParam("ROIScale", "Determines the size of search window around a blob");
m_param_only_roi = 1;
AddParam("OnlyROI", &m_param_only_roi);
CommentParam("OnlyROI", "Shows the whole debug image (0) or only ROIs where the detector was applied (1)");
m_min_window_size = cvSize(0,0);
m_max_border = 0;
m_roi_seq = cvCreateSeq( 0, sizeof(*m_roi_seq), sizeof(CvRect), cvCreateMemStorage() );
SetModuleName("CC");
}
void WorldServerNormal::OnWorldDisconnect(ServerInfo* pInfo)
{
MyLog::error("<<--Server Manager Remove War World!");
AUTOLOCK(m_lockLoginWar);
m_nConnectWarState = eCWS_Waiting;
Servers.m_pWarWorld = NULL;
SetModuleName("World");
WorldGuildManager::Instance().OnDisconnectWarWorld();
}
CvBlobTrackPostProcTimeAver( int KernelType = 0)
{
int i;
m_Frame = 0;
for(i=0;i<TIME_WND;++i)
{
m_Weights[i] = 1;
if(KernelType == 1)
{
m_Weights[i] = (float)exp((-2.3*i)/(TIME_WND-1)); /* last weight is 0.1 of first weight */
}
}
SetModuleName("TimeAver");
};
void CActiveXUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
{
switch(pstrName[0])
{
case 'c':
if( _tcscmp(pstrName, _T("clsid")) == 0 ) {CreateControl(pstrValue);return ;}
break
case 'm':
if( _tcscmp(pstrName, _T("modulename")) == 0 ) {SetModuleName(pstrValue);return ;}
break;
case 'd':
if( _tcscmp(pstrName, _T("delaycreate")) == 0 ) {SetDelayCreate(_tcscmp(pstrValue, _T("true")) == 0);return ;}
break;
}
CControlUI::SetAttribute(pstrName, pstrValue);
}
void SetupAudioSettings (void)
{
SetModuleName("AndroidAudio");
RegisterSetting(Output_SwapChannels, Data_DWORD_General, "SwapChannels", "", 0, NULL);
RegisterSetting(Output_DefaultFrequency, Data_DWORD_General, "DefaultFrequency", "", DEFAULT_FREQUENCY, NULL);
RegisterSetting(Buffer_PrimarySize, Data_DWORD_General, "BufferPrimarySize", "", PRIMARY_BUFFER_SIZE, NULL);
RegisterSetting(Buffer_SecondarySize, Data_DWORD_General, "BufferSecondarySize", "", SECONDARY_BUFFER_SIZE, NULL);
RegisterSetting(Buffer_SecondaryNbr, Data_DWORD_General, "BufferSecondaryNbr", "", SECONDARY_BUFFER_NBR, NULL);
RegisterSetting(Logging_LogAudioInitShutdown, Data_DWORD_General, "AudioInitShutdown", "Logging", g_ModuleLogLevel[TraceAudioInitShutdown], NULL);
RegisterSetting(Logging_LogAudioInterface, Data_DWORD_General, "AudioInterface", "Logging", g_ModuleLogLevel[TraceAudioInterface], NULL);
g_SwapChannels = GetSetting(Output_SwapChannels);
g_GameFreq = GetSetting(Output_DefaultFrequency);
g_ModuleLogLevel[TraceAudioInitShutdown] = GetSetting(Logging_LogAudioInitShutdown);
g_ModuleLogLevel[TraceAudioInterface] = GetSetting(Logging_LogAudioInterface);
}
/* Constructor of auto blob tracker: */
CvBlobTrackerAuto1::CvBlobTrackerAuto1(CvBlobTrackerAutoParam1* param):m_BlobList(sizeof(CvBlobTrackAuto))
{
m_BlobList.AddFormat("i");
m_TimesFile = NULL;
AddParam("TimesFile",&m_TimesFile);
m_NextBlobID = 0;
m_pFGMask = NULL;
m_FrameCount = 0;
m_FGTrainFrames = param?param->FGTrainFrames:0;
m_pFG = param?param->pFG:0;
m_BDDel = 0;
m_pBD = param?param->pBD:NULL;
m_BTDel = 0;
m_pBT = param?param->pBT:NULL;;
m_BTReal = m_pBT?m_pBT->IsModuleName("BlobTrackerReal"):0;
m_pBTGen = param?param->pBTGen:NULL;
m_pBTA = param?param->pBTA:NULL;
m_pBTPostProc = param?param->pBTPP:NULL;
m_UsePPData = param?param->UsePPData:0;
/* Create default submodules: */
if(m_pBD==NULL)
{
m_pBD = cvCreateBlobDetectorSimple();
m_BDDel = 1;
}
if(m_pBT==NULL)
{
m_pBT = cvCreateBlobTrackerMS();
m_BTDel = 1;
}
SetModuleName("Auto1");
} /* CvBlobTrackerAuto1::CvBlobTrackerAuto1 */
CvBlobTrackerCCCR(CvBlobTrackerOne* (*CreateCR)(), char* CRName):m_BlobList(sizeof(DefBlobTrackerCR))
{
m_CreateCR = CreateCR;
m_pMem = cvCreateMemStorage();
m_Collision = 1; /* if 1 then collistion will be detected and processed */
m_AlphaSize = 0.05f;
AddParam("AlphaSize",&m_AlphaSize);
CommentParam("AlphaSize", "Size update speed (0..1)");
strcpy(m_ModuleName, "CC");
if(CRName)strcat(m_ModuleName,CRName);
SetModuleName(m_ModuleName);
{
CvBlobTrackerOne* pM = m_CreateCR();
TransferParamsFromChild(pM,NULL);
pM->Release();
}
SetParam("SizeVar",0);
};
void WorldServerNormal::OnWorldConnect(int32 nSrvID, int32 nSocketID, bool bWarGrp, SockAddr& laddr)
{
if( bWarGrp )
{
AUTOLOCK(m_lockLoginWar);
ServerInfo* pInfo = Servers.AddWarWorld( nSrvID, nSocketID, laddr);
if( pInfo != NULL )
{
m_nConnectWarState = eCWS_Succeed;
SetModuleName("SubWorld");
WorldGuildManager::Instance().OnConnectWarWorld();
}
}
else
{
MyLog::error("World connect to World Error !");
return;
}
}
void CTypeInfo::SetModuleName(const char* name)
{
SetModuleName(string(name));
}
CvFGDetectorBase(int type, void* param)
{
m_pFG = NULL;
m_FGType = type;
m_pFGParam = param;
if( m_FGType == CV_BG_MODEL_FGD || m_FGType == CV_BG_MODEL_FGD_SIMPLE )
{
if(m_pFGParam)
{
m_ParamFGD = *(CvFGDStatModelParams*)m_pFGParam;
}
else
{
m_ParamFGD.Lc = CV_BGFG_FGD_LC;
m_ParamFGD.N1c = CV_BGFG_FGD_N1C;
m_ParamFGD.N2c = CV_BGFG_FGD_N2C;
m_ParamFGD.Lcc = CV_BGFG_FGD_LCC;
m_ParamFGD.N1cc = CV_BGFG_FGD_N1CC;
m_ParamFGD.N2cc = CV_BGFG_FGD_N2CC;
m_ParamFGD.delta = CV_BGFG_FGD_DELTA;
m_ParamFGD.alpha1 = CV_BGFG_FGD_ALPHA_1;
m_ParamFGD.alpha2 = CV_BGFG_FGD_ALPHA_2;
m_ParamFGD.alpha3 = CV_BGFG_FGD_ALPHA_3;
m_ParamFGD.T = CV_BGFG_FGD_T;
m_ParamFGD.minArea = CV_BGFG_FGD_MINAREA;
m_ParamFGD.is_obj_without_holes = 1;
m_ParamFGD.perform_morphing = 1;
}
AddParam("LC",&m_ParamFGD.Lc);
AddParam("alpha1",&m_ParamFGD.alpha1);
AddParam("alpha2",&m_ParamFGD.alpha2);
AddParam("alpha3",&m_ParamFGD.alpha3);
AddParam("N1c",&m_ParamFGD.N1c);
AddParam("N2c",&m_ParamFGD.N2c);
AddParam("N1cc",&m_ParamFGD.N1cc);
AddParam("N2cc",&m_ParamFGD.N2cc);
m_SaveName = 0;
m_LoadName = 0;
AddParam("SaveName",&m_SaveName);
AddParam("LoadName",&m_LoadName);
AddParam("ObjWithoutHoles",&m_ParamFGD.is_obj_without_holes);
AddParam("Morphology",&m_ParamFGD.perform_morphing);
SetModuleName("FGD");
}
else if( m_FGType == CV_BG_MODEL_MOG ) // "MOG" == "Mixture Of Gaussians"
{
if(m_pFGParam)
{
m_ParamMOG = *(CvGaussBGStatModelParams*)m_pFGParam;
}
else
{ // These constants are all from cvaux/include/cvaux.h
m_ParamMOG.win_size = CV_BGFG_MOG_WINDOW_SIZE;
m_ParamMOG.bg_threshold = CV_BGFG_MOG_BACKGROUND_THRESHOLD;
m_ParamMOG.std_threshold = CV_BGFG_MOG_STD_THRESHOLD;
m_ParamMOG.weight_init = CV_BGFG_MOG_WEIGHT_INIT;
m_ParamMOG.variance_init = CV_BGFG_MOG_SIGMA_INIT*CV_BGFG_MOG_SIGMA_INIT;
m_ParamMOG.minArea = CV_BGFG_MOG_MINAREA;
m_ParamMOG.n_gauss = CV_BGFG_MOG_NGAUSSIANS;
}
AddParam("NG",&m_ParamMOG.n_gauss);
SetModuleName("MOG");
}
};
CvBlobTrackAnalysisList(CvBlobTrackAnalysisOne* (*create)()):m_TrackAnalyserList(sizeof(DefTrackAnalyser))
{
m_Frame = 0;
m_CreateAnalysis = create;
SetModuleName("List");
}
