void BlockMatcher::FindBestMatchSubp( const int xpos, const int ypos,
const CandidateList& cand_list,
const MVector& mv_prediction,
const float lambda)
{
BlockDiffParams dparams;
dparams.SetBlockLimits( m_bparams , m_pic_data , xpos , ypos);
//now test against the offsets in the MV list to get the lowest cost//
//////////////////////////////////////////////////////////////////////
// Numbers of the lists to do more searching in
vector<int> list_nums;
// Costs of the initial vectors in each list
OneDArray<float> list_costs( cand_list.size() );
// First test the first in each of the lists to choose which lists to pursue
MvCostData best_costs( m_cost_array[ypos][xpos] );
best_costs.total = 100000000.0f;
MVector best_mv( m_mv_array[ypos][xpos] );
MvCostData cand_costs;
MVector cand_mv;
for (size_t list_num=0 ; list_num<cand_list.size() ; ++list_num )
{
for (size_t i=0 ; i<cand_list[list_num].size() ; ++i )
{
cand_mv = cand_list[list_num][i];
cand_costs.mvcost = GetVarUp( mv_prediction , cand_mv );
m_subpeldiff[m_precision-1]->Diff( dparams,
cand_mv ,
cand_costs.mvcost,
lambda,
best_costs ,
best_mv);
}//
}// list_num
// Write the results in the arrays //
/////////////////////////////////////
m_mv_array[ypos][xpos] = best_mv;
m_cost_array[ypos][xpos] = best_costs;
}
std::string
gams::elections::ElectionCumulative::get_leader(void)
{
madara_logger_ptr_log(gams::loggers::global_logger.get(),
gams::loggers::LOG_MAJOR,
"gams::elections::ElectionCumulative:get_leader" \
" getting leader from %s\n", election_prefix_.c_str());
std::string leader;
CandidateList leaders = get_leaders();
if (leaders.size() > 0)
{
leader = leaders[0];
}
return leader;
}
void AddNewVlistD( CandidateList& vect_list , const MVector& mv , const int xr , const int yr )
{
//As above, but using a diamond pattern
vector<MVector> tmp_list;
vect_list.push_back( tmp_list );
int list_num=vect_list.size()-1;
int xlim;
MVector tmp_mv( mv );
AddVect( vect_list , tmp_mv , list_num );
for ( int i=1 ; i<=xr ; ++i)
{
tmp_mv.x = mv.x + i;
AddVect( vect_list , tmp_mv , list_num );
tmp_mv.x = mv.x - i;
AddVect( vect_list , tmp_mv , list_num );
}
for ( int j=1 ; j<=yr ; ++j)
{
xlim = xr * (yr-std::abs(j)) / yr;
for ( int i=-xlim ; i<=xlim ; ++i)
{
tmp_mv.x = mv.x + i;
tmp_mv.y = mv.y + j;
AddVect( vect_list , tmp_mv , list_num );
tmp_mv.y = mv.y - j;
AddVect( vect_list , tmp_mv , list_num );
}
}
// If we've not managed to add any element to the list
// remove the list so we don't ever have to check its size
if ( vect_list[list_num].size() == 0 )
vect_list.erase( vect_list.begin() + list_num );
}
void AddNewVlist( CandidateList& vect_list, const MVector& mv,
const int xr , const int yr , const int step )
{
//Creates a new motion vector list in a square region around mv
vector<MVector> tmp_list;
vect_list.push_back(tmp_list);
int list_num=vect_list.size()-1;
MVector tmp_mv( mv );
AddVect(vect_list , tmp_mv , list_num );
for ( int i=1 ; i<=xr ; ++i )
{
tmp_mv.x = mv.x + i*step;
AddVect( vect_list , tmp_mv , list_num );
tmp_mv.x = mv.x - i*step;
AddVect( vect_list , tmp_mv , list_num );
}
for ( int j=1 ; j<=yr ; ++j)
{
for ( int i=-xr ; i<=xr ; ++i)
{
tmp_mv.x = mv.x + i*step;
tmp_mv.y = mv.y + j*step;
AddVect(vect_list,tmp_mv,list_num);
tmp_mv.y = mv.y -j*step;
AddVect(vect_list,tmp_mv,list_num);
}// i
}// j
// If we've not managed to add any element to the list
// remove the list so we don't ever have to check its size
if ( vect_list[list_num].size() == 0 )
vect_list.erase( vect_list.begin() + list_num );
}
gams::elections::CandidateList
gams::elections::ElectionCumulative::get_leaders(int num_leaders)
{
madara_logger_ptr_log(gams::loggers::global_logger.get(),
gams::loggers::LOG_MAJOR,
"gams::elections::ElectionCumulative:get_leaders" \
" getting leaders from %s\n", election_prefix_.c_str());
CandidateList leaders;
if (knowledge_)
{
knowledge::ContextGuard guard(*knowledge_);
typedef std::map <KnowledgeRecord::Integer, CandidateList> Leaderboard;
CandidateVotes candidates;
Leaderboard leaderboard;
get_votes(candidates);
// construct the leaderboard
for (CandidateVotes::iterator i = candidates.begin();
i != candidates.end(); ++i)
{
leaderboard[i->second].push_back(i->first);
}
// leaderboard is in ascending order, so grab from the back
for (Leaderboard::reverse_iterator i = leaderboard.rbegin();
i != leaderboard.rend() &&(int) leaders.size() < num_leaders; ++i)
{
// if it is a tie, we could provide more than num_leaders
leaders.insert(leaders.end(), i->second.begin(), i->second.end());
}
}
return leaders;
}
void BlockMatcher::FindBestMatchPel(const int xpos , const int ypos ,
const CandidateList& cand_list,
const MVector& mv_prediction,
const int list_start)
{
BlockDiffParams dparams;
dparams.SetBlockLimits( m_bparams , m_pic_data , xpos , ypos);
//now test against the offsets in the MV list to get the lowest cost//
//////////////////////////////////////////////////////////////////////
// First test the first in each of the lists to choose which lists to pursue
float best_cost = m_cost_array[ypos][xpos].total;
MVector best_mv = m_mv_array[ypos][xpos];
for ( size_t lnum=list_start ; lnum<cand_list.size() ; ++lnum)
{
for (size_t i=0 ; i<cand_list[lnum].size() ; ++i)
{
m_peldiff.Diff( dparams ,
cand_list[lnum][i] ,
best_cost ,
best_mv);
}// i
}// num
// Write the results in the arrays //
/////////////////////////////////////
m_mv_array[ypos][xpos] = best_mv;
m_cost_array[ypos][xpos].SAD = best_cost;
m_cost_array[ypos][xpos].mvcost = GetVar( mv_prediction , best_mv);
m_cost_array[ypos][xpos].SetTotal( 0.0 );
}
void AddVect(CandidateList& vect_list,const MVector& mv,int list_num)
{
bool is_in_list=false;
size_t lnum=0;
size_t i;
while( !is_in_list && lnum<vect_list.size() )
{
i=0;
while( !is_in_list && i<vect_list[lnum].size())
{
if ( vect_list[lnum][i].x == mv.x && vect_list[lnum][i].y == mv.y )
is_in_list=true;
++i;
}
++lnum;
}
if ( !is_in_list )
vect_list[list_num].push_back(mv);
}