void DataPartitions::doFrequency(DoubleVector dimData){
m_partitions.clear();
PairVector dimOrData;
initPairs(dimOrData, dimData);
pairSort(dimOrData);
int dimsize = dimData.size();
int nBins = this->m_rddtClust->m_rddtOp->m_nBins;
if(nBins == 0 ){
nBins = 1;
}
if(nBins>dimsize){
nBins = dimsize;
}
for(int i = 0; i< nBins; i++){
DataPartition* partition = new DataPartition();
partition->setPartitions(this);
partition->m_partitionIdx = i;
this->m_partitions.push_back(partition);
}
int partitionsize = (int)ceil((double)dimsize/(double)nBins);
for(unsigned i = 0; i< dimOrData.size(); i++){
int p = (int)((double)i/(double)partitionsize);
if(p>(int)m_partitions.size())
p=m_partitions.size();
int first = (dimOrData[i]).first;
(m_partitions[p])->m_parIndices.push_back(first);
}
}
void DataPartitions::doRange(DoubleVector dimData){
m_partitions.clear();
PairVector dimOrData;
initPairs(dimOrData, dimData);
pairSort(dimOrData);
//todo
}
/* This function will be called when the service loaded */
int search_record_init_service(ci_service_xdata_t * srv_xdata,
struct ci_server_conf *server_conf)
{
ci_debug_printf(5, "Initialization of Search Record module......\n");
/*Tell to the icap clients that we can support up to 1024 size of preview data*/
ci_service_set_preview(srv_xdata, 128);
/*Tell to the icap clients that we support 204 responses*/
ci_service_enable_204(srv_xdata);
/*Tell to the icap clients to send preview data for all files*/
ci_service_set_transfer_preview(srv_xdata, "*");
/*Tell to the icap clients that we want the X-Authenticated-User and X-Authenticated-Groups headers
which contains the username and the groups in which belongs. */
/*ci_service_set_xopts(srv_xdata, CI_XAUTHENTICATEDUSER|CI_XAUTHENTICATEDGROUPS);*/
initPairs(&search_engine);
addNewPair(&search_engine,baidu_matchurl,baidu_wordlist,baidu_site);
addNewPair(&search_engine,google_matchurl,google_wordlist,google_site);
return CI_OK;
}
void MinuMatchTico::Pairing(unsigned int nAlignment)
{
int n1 = pMinus[0]->size();
int n2 = pMinus[1]->size();
// Assume all_pairs have been sorted
vector<MinuPair> initPairs(all_pairs.begin(), all_pairs.begin()+nAlignment);
for(unsigned int i = 0; i < nAlignment; i++)
{
// Alignment
Minu initMinu[2];
initMinu[0] = (*(pMinus[0]))[initPairs[i].index[0]];
initMinu[1] = (*(pMinus[1]))[initPairs[i].index[1]];
Tran tran;
int rot = NormalizeMinuDir(initMinu[1].dir-initMinu[0].dir);
tran.rotC = cos(rot*M_PI/180);
tran.rotS = sin(rot*M_PI/180);
tran.dx = initMinu[1].x - initMinu[0].x * tran.rotC - initMinu[0].y * tran.rotS;
tran.dy = initMinu[1].y + initMinu[0].x * tran.rotS - initMinu[0].y * tran.rotC;
vector<Minu> minuz(*(pMinus[0]));
TransMinus(minuz, tran);
for(unsigned int m = 0; m < minuz.size(); m++)
minuz[m].dir = NormalizeMinuDir(minuz[m].dir + rot);
// Match
vector<MinuPair> match_pairs;
match_pairs.push_back(MinuPair(initPairs[i].index[0], initPairs[i].index[1], 0));
vector<bool> used_flag1(n1, false), used_flag2(n2, false);
used_flag1[initPairs[i].index[0]] = true;
used_flag2[initPairs[i].index[1]] = true;
for(unsigned int m = 0; m < all_pairs.size(); m++)
{
if(all_pairs[m].score==0)
break;
//if(g_pairRank[allPairs[m].ii*g_nMinu[1]+allPairs[m].jj]>g_thRank)
// continue;
//if(g_minuSimi[allPairs[m].ii*g_nMinu[1]+allPairs[m].jj]<=g_thSimi)
// continue;
if(all_pairs[m].score<=10)
break;
int ii = all_pairs[m].index[0];
int jj = all_pairs[m].index[1];
if(used_flag1[ii] || used_flag2[jj])
continue;
// geometrically compatible with initial pair
double dx = minuz[ii].x - (*(pMinus[1]))[jj].x;
double dy = minuz[ii].y - (*(pMinus[1]))[jj].y;
double diff_pos = sqrt(dx*dx+dy*dy);
int ddir = minuz[ii].dir - (*(pMinus[1]))[jj].dir;
dx = (*(pMinus[0]))[initPairs[i].index[0]].x - (*(pMinus[0]))[ii].x;
dy = (*(pMinus[0]))[initPairs[i].index[0]].y - (*(pMinus[0]))[ii].y;
double lLen = sqrt(dx*dx+dy*dy);
double diff_pos_th;
if(lLen <= LEN_BOUND[0])
diff_pos_th = DIFF_POS[0];
else if(lLen >= LEN_BOUND[BOUND_NUM-1])
diff_pos_th = DIFF_POS[BOUND_NUM-1];
else if(lLen<=LEN_BOUND[1])
diff_pos_th = DIFF_POS[0] + (lLen-LEN_BOUND[0]) * (DIFF_POS[1]-DIFF_POS[0])/(LEN_BOUND[1]-LEN_BOUND[0]);
else
diff_pos_th = DIFF_POS[1] + (lLen-LEN_BOUND[1]) * (DIFF_POS[2]-DIFF_POS[1])/(LEN_BOUND[2]-LEN_BOUND[1]);
if(diff_pos<=diff_pos_th && abs(NormalizeMinuDir(ddir))<=30)
{
used_flag1[ii] = true;
used_flag2[jj] = true;
match_pairs.push_back(MinuPair(ii, jj, 0));
if((int)match_pairs.size() >= min(n1, n2))
break;
}
}
match_pair_sets.push_back(match_pairs);
}
}
