LinearFeatureResponseSVM LinearFeatureResponseSVM::CreateRandom(Random& random, const IDataPointCollection& data, unsigned int* dataIndices, const unsigned int i0, const unsigned int i1,float svm_c, FeatureMaskType featureMask, bool root_node)
{
LinearFeatureResponseSVM lr;
DataPointCollection& concreteData = (DataPointCollection&)(data);
//this->dimensions_ = concreteData.Dimensions();
lr.dimensions_ = concreteData.Dimensions();
switch(featureMask)
{
case fisher:GenerateMaskFisher (random, lr.vIndex_, lr.dimensions_, root_node); //CHANGE THIS DEPENDING ON OPERATION
break;
case lbp:GenerateMaskLBP (random, lr.vIndex_, lr.dimensions_, root_node); //CHANGE THIS DEPENDING ON OPERATION
break;
case hypercolumn: GenerateMaskHypercolumn (random, lr.vIndex_, lr.dimensions_, root_node); //CHANGE THIS DEPENDING ON OPERATION
break;
case standard:GenerateMask (random, lr.vIndex_, lr.dimensions_, root_node); //CHANGE THIS DEPENDING ON OPERATION
break;
case hypercolumn_loc:GenerateMaskHypercolumnStatisticsAndLocation (random, lr.vIndex_, lr.dimensions_, root_node); //CHANGE THIS DEPENDING ON OPERATION
break;
case hypercolumn2:GenerateMaskHypercolumn2LrStatistics (random, lr.vIndex_, lr.dimensions_, root_node); //CHANGE THIS DEPENDING ON OPERATION
break;
case hypercolumn_loc_color:GenerateMaskHypercolumnStatisticsColorAndLocation (random, lr.vIndex_, lr.dimensions_, root_node); //CHANGE THIS DEPENDING ON OPERATION
break;
case hypercolumn_lbp_loc_color:GenerateMaskHypercolumnStatisticsLBPColorAndLocation (random, lr.vIndex_, lr.dimensions_, root_node); //CHANGE THIS DEPENDING ON OPERATION
break;
default: std::cout<<"Using unknown mask function. Re-check parameters"<<std::endl;
}
std::sort(lr.vIndex_.begin(), lr.vIndex_.end());
lr.vIndex_.erase( unique( lr.vIndex_.begin(), lr.vIndex_.end() ), lr.vIndex_.end() );
cv::Ptr<cvml::SVM> svm;
svm = cvml::SVM::create();
svm->setType(cvml::SVM::C_SVC);
svm->setKernel(cvml::SVM::LINEAR);
svm->setTermCriteria(cv::TermCriteria(cv::TermCriteria::MAX_ITER+cv::TermCriteria::EPS, 1000, 0.01));
svm->setC(svm_c);
//cv::Ptr<cvml::TrainData> tdata = concreteData.getTrainDataWithMask(lr.vIndex_,i0,i1);
cv::Ptr<cvml::TrainData> tdata = concreteData.getTrainDataWithMaskOrdered(lr.vIndex_,i0,i1,dataIndices);
svm->train(tdata);
lr.nWeights_ = lr.vIndex_.size();
lr.vWeights_.resize(lr.vIndex_.size(),1); //Initializing weights as unit vector
lr.bias_ = 0; // 0 ->bias
if(svm->isTrained())
{
cv::Mat alpha, wts;
lr.bias_ = -1 * (float)svm->getDecisionFunction(0, alpha, wts);
cv::Mat svs = svm->getSupportVectors();
for(int j=0;j<svs.cols;j++)
lr.vWeights_[j]=(svs.at<float>(j));
}
svm.release();
//lr.vWeights_.resize()
//cv::Mat svs = lr.svm->getSupportVectors();
//svm->getDecisionFunction(0,alpha,svs);
//std::cout<<"[DEBUG : "<<i0<<" -->"<<i1<<"] "<<tdata->getNSamples()<<std::endl;
//std::cout<<"[DEBUG : FeatureResponseSVM / isTrained?]"<<lr.nWeights_<<" "<<lr.svm->isTrained()<<std::endl;
return lr;
}
void ComparatorNoiseCorrector::CorrectComparatorNoise(short *_image, int _rows, int _cols, int _frames,
Mask *_mask,bool verbose, bool aggressive_correction, bool beadfind_image, int threadNum, int _regionXSize, int _regionYSize)
{
char *allocPtr;
image=_image;
regionXSize=_regionXSize;
regionYSize=_regionYSize;
double wholeStart,start;
wholeStart = start = CNCTimer();
allocPtr=AllocateStructs(threadNum, _rows, _cols, _frames);
allocTime = CNCTimer()-start;
start = CNCTimer();
if(_mask == NULL)
GenerateMask(mMask);
else
GenerateIntMask(_mask);
maskTime = CNCTimer()-start;
start = CNCTimer();
NNSpan = 5;
if(regionXSize > 0)
{//thumbnail image
int nYPatches = rows / regionYSize;
for(int pRow = 0; pRow < nYPatches; pRow++){
//printf(" patch %d\n",pRow*regionYSize);
CorrectComparatorNoise_internal( verbose, aggressive_correction, pRow*regionYSize,(((pRow+1)*regionYSize)));
}
}
else if (!beadfind_image)
{
CorrectComparatorNoise_internal( verbose, aggressive_correction);
mainTime = CNCTimer()-start;
if (aggressive_correction)
{
int blk_size = 96;
int sub_blocks = rows / blk_size;
start=CNCTimer();
if (blk_size * sub_blocks < rows) {
sub_blocks++;
}
for (int blk = 0; blk < sub_blocks; blk++)
{
int row_start = blk * blk_size;
int row_end = (blk + 1) * blk_size;
if (blk == sub_blocks - 1) row_end = rows;
CorrectComparatorNoise_internal( verbose, aggressive_correction, row_start, row_end, true);
}
aggTime = CNCTimer()-start;
}
}
else
{
// trick correction into only doing hf noise correction as this is all that works for beadfind images
CorrectComparatorNoise_internal( verbose, aggressive_correction, 0, rows,true);
}
// ClearPinned(); // re-zero pinned pixels
totalTime = CNCTimer()-wholeStart;
#ifdef DBG_PRINT_TIMES
printf("CNC took %.2lf alloc=%.2f mask=%.2f main=%.2f agg=%.2f sum=%.2f apply=%.2f tm1=%.2f tm2=%.2f(%.2f/%.2f) nn=%.2f msk=%.2f pca=%.2f\n",
totalTime,allocTime,maskTime,mainTime,aggTime,sumTime,applyTime,tm1,tm2,tm2_1,tm2_2,nnsubTime,mskTime,tm2_3);
#endif
FreeStructs(threadNum,false,allocPtr);
}
//_________________________________________________________________
Bool_t SelectPPCoincMapRegions::Process(Long64_t entry)
{
if (entry % (nentries/1000)== 0)
{
std::cout << std::setiosflags( std::ios::fixed );
std::cout.precision(1);
std::cout << "\r"
<< std::setw(8) << std::right <<(100.0*entry)/nentries
<< "% completed";
std::cout.flush();
std::cout << std::resetiosflags( std::ios::fixed );
}
else if (entry == (nentries - 1 ))
{
std::cout << std::setiosflags( std::ios::fixed );
std::cout.precision(1);
std::cout << "\r" << std::setw(8) << std::right << 100 << "% completed ";
std::cout.flush();
std::cout << std::resetiosflags( std::ios::fixed );
}
b_evnum->GetEntry(entry);
b_run->GetEntry(entry);
b_trigger->GetEntry(entry);
bpmval = 0;
tdcval = 0;
Double_t adc_val, tdc_val;
Float_t tofval;
std::fill(region_multiplicity.begin(), region_multiplicity.end(),0);
std::fill(mult_mismatch.begin(), mult_mismatch.end(),0);
UInt_t region = 0;
for (incr=fChLow;incr<=fChHigh;incr++)
{
for (UInt_t j=0; j<fNRegions+2; j++)
{
data_in_region_of_strip[j][incr] = false;
}
b_adc[incr]->GetEntry(entry);
adc_val = nt_adc[incr];
b_tdc[incr]->GetEntry(entry);
tdc_val = nt_tdc[incr];
// TOF corresponds to appropriate BPM channel
tofval = nt_tdc[32*(incr/32+1)-1]-tdc_val;
if (adc_val>fPedThresh[incr])
{
region = ComputeRegion(incr, adc_val);
data_in_region_of_strip[region][incr] = true;
region_multiplicity[region]++;
}
}
// count nonzero regions
Int_t nregions = std::count_if(region_multiplicity.begin(),
region_multiplicity.end(),
std::bind2nd(std::greater<UInt_t>(),0));
// sum the multiplicities of each region
Int_t mult = std::accumulate(region_multiplicity.begin(),
region_multiplicity.end(),
0,
std::plus<UInt_t>());
// std::cout << "Generating mask " << std::endl; std::cout.flush();
std::string mask = GenerateMask(region_multiplicity);
// std::cout << "consolidating mask " << mask << std::endl; std::cout.flush();
// mask = MultiplicityGroupGenerator::ConsolidateCombo(mask, fNRegions+2);
if (mult>0 && mult<=fMaxMult)
{
// std::cout << "filling mult=" << mult << "\tmask=" << mask << std::endl; std::cout.flush();
regional_coinc[mult]->Fill(mask.data(),1.0);
}
return kTRUE;
}
void CModAPI_WorldEvent_AnimatedText::Send(vec2 Pos, int ItemLayer, const char* pText, int Size, vec4 Color, int Alignment, int AnimationID, int Duration, vec2 Offset)
{
CNetEvent_ModAPI_AnimatedText *pEvent = (CNetEvent_ModAPI_AnimatedText *)GameServer()->m_Events.Create(NETEVENTTYPE_MODAPI_ANIMATEDTEXT, sizeof(CNetEvent_ModAPI_AnimatedText), GenerateMask());
if(pEvent)
{
pEvent->m_X = (int)Pos.x;
pEvent->m_Y = (int)Pos.y;
pEvent->m_ItemLayer = ItemLayer;
pEvent->m_Alignment = Alignment;
pEvent->m_Color = ModAPI_ColorToInt(Color);
pEvent->m_Size = Size;
StrToInts(pEvent->m_aText, 16, pText);
pEvent->m_AnimationId = AnimationID;
pEvent->m_Duration = Duration;
pEvent->m_OffsetX = (int)Offset.x;
pEvent->m_OffsetY = (int)Offset.y;
}
}
void CModAPI_WorldEvent_Sound::Send(vec2 Pos, int Sound)
{
if (Sound < 0)
return;
// create a sound
CNetEvent_SoundWorld *pEvent = (CNetEvent_SoundWorld *)GameServer()->m_Events.Create(NETEVENTTYPE_SOUNDWORLD, sizeof(CNetEvent_SoundWorld), GenerateMask());
if(pEvent)
{
pEvent->m_X = (int)Pos.x;
pEvent->m_Y = (int)Pos.y;
pEvent->m_SoundID = Sound;
}
}
void CModAPI_WorldEvent_ExplosionEffect::Send(vec2 Pos)
{
CNetEvent_Explosion *pEvent = (CNetEvent_Explosion *)GameServer()->m_Events.Create(NETEVENTTYPE_EXPLOSION, sizeof(CNetEvent_Explosion), GenerateMask());
if(pEvent)
{
pEvent->m_X = (int)Pos.x;
pEvent->m_Y = (int)Pos.y;
}
}
void CModAPI_WorldEvent_DeathEffect::Send(vec2 Pos, int ClientID)
{
CNetEvent_Death *pEvent = (CNetEvent_Death *)GameServer()->m_Events.Create(NETEVENTTYPE_DEATH, sizeof(CNetEvent_Death), GenerateMask());
if(pEvent)
{
pEvent->m_X = (int)Pos.x;
pEvent->m_Y = (int)Pos.y;
pEvent->m_ClientID = ClientID;
}
}
void CModAPI_WorldEvent_DamageIndicator::Send(vec2 Pos, float Angle, int Amount)
{
float a = 3*pi/2 + Angle;
//float a = get_angle(dir);
float s = a-pi/3;
float e = a+pi/3;
for(int i = 0; i < Amount; i++)
{
float f = mix(s, e, float(i+1)/float(Amount+2));
CNetEvent_DamageInd *pEvent = (CNetEvent_DamageInd *)GameServer()->m_Events.Create(NETEVENTTYPE_DAMAGEIND, sizeof(CNetEvent_DamageInd), GenerateMask());
if(pEvent)
{
pEvent->m_X = (int)Pos.x;
pEvent->m_Y = (int)Pos.y;
pEvent->m_Angle = (int)(f*256.0f);
}
}
}
void CModAPI_WorldEvent_HammerHitEffect::Send(vec2 Pos)
{
CNetEvent_HammerHit *pEvent = (CNetEvent_HammerHit *)GameServer()->m_Events.Create(NETEVENTTYPE_HAMMERHIT, sizeof(CNetEvent_HammerHit), GenerateMask());
if(pEvent)
{
pEvent->m_X = (int)Pos.x;
pEvent->m_Y = (int)Pos.y;
}
}
void CModAPI_WorldEvent_SpawnEffect::Send(vec2 Pos)
{
CNetEvent_Spawn *ev = (CNetEvent_Spawn *)GameServer()->m_Events.Create(NETEVENTTYPE_SPAWN, sizeof(CNetEvent_Spawn), GenerateMask());
if(ev)
{
ev->m_X = (int)Pos.x;
ev->m_Y = (int)Pos.y;
}
}
