texture_2d tangent_flow_map(const texture_2d& src, float sigma) {
texture_2d tmp0(src.clone_format());
texture_2d tmp1(src.clone_format());
texture_2d dst(src.clone_format());
glsl_program sst("sst_fs.glsl");
sst.use();
sst.bind_sampler("img", src);
sst.set_uniform_2f("img_size", (float)src.get_width(), (float)src.get_height());
sst.draw(&tmp0);
glsl_program gauss("gauss_fs.glsl");
gauss.use();
gauss.bind_sampler("img", tmp0);
gauss.set_uniform_2f("img_size", (float)src.get_width(), (float)src.get_height());
gauss.set_uniform_1f("sigma", sigma);
gauss.draw(&tmp1);
glsl_program tfm("tfm_fs.glsl");
tfm.use();
tfm.bind_sampler("img", tmp1);
tfm.set_uniform_2f("img_size", (float)src.get_width(), (float)src.get_height());
tfm.draw(&dst);
return dst;
}
//**********************************************************************
double stringToDouble(string str)
// Return the 1st doubles number read from the string "str". "str" should be a string containing a line of data.
{
stringstream sst(str+" "); // add a blank at the end so the last data will be read
double val;
sst >> val;
return val;
}
void TransferForm::saveConfig()
{
QString sst(SET_SEC_TRANS);
Setting::save(sst+SET_KEY_CMBSA, SET_PFX_CMBITM, *m_ui.cmbSrcAddr, false);
Setting::save(sst+SET_KEY_CMBDA, SET_PFX_CMBITM, *m_ui.cmbDstAddr);
Setting::save(sst+SET_KEY_CMBSP, SET_PFX_CMBITM, *m_ui.cmbSrcPort);
Setting::save(sst+SET_KEY_CMBDP, SET_PFX_CMBITM, *m_ui.cmbDstPort);
QString skl(SET_SEC_DIR); skl += SET_KEY_LOG;
Setting::set(skl, SET_KEY_TRANS, property(SET_SEC_DIR).toString());
}
void TestPlat::run() {
SelectMenu();
string str1;
getline(cin,str1);
while(str1 != "q"){
int j = 0;
stringstream sst(str1);
sst >> j;
if(!sst || !sst.eof()){
cerr << "Not Number or there's space ! Try Again!" <<endl;
getline(cin,str1);
continue;
}
if(j >= TestPlat::SlnList.size() || j < 0){
cerr << "Invalid number(should < " << TestPlat::SlnList.size() << ")! Try again!" << endl;
getline(cin,str1);
continue;
}
int i = 0;
for(auto& it : TestPlat::SlnList){
if(i == j){
SlnBase* p = it.second();
cout << "---------------------------" << endl;
cout << it.first << endl;
cout << "---------------------------" << endl;
Start(p);
delete p;
cout << "------------DONE-----------" << endl;
break;
}
i++;
}
cout << " 'r or enter'(re-run) 'm' (menu) 'q' (quit) or Alogorithm id!" << endl;
string tmp;
getline(cin,tmp);
//cout << "your enter: " << tmp << endl;
if(tmp == "" || tmp == "r") continue;
if(tmp == "q") {
cout<< "Quit the TestPlat" << endl;
return;
}
if(tmp == "m"){
SelectMenu();
getline(cin,str1);
continue;
}
str1 = tmp;
}
}
//**********************************************************************
vector<double> stringToDoubles(string str)
// Return a vector of doubles from the string "str". "str" should
// be a string containing a line of data.
{
stringstream sst(str+" "); // add a blank at the end so the last data will be read
vector<double> valueList;
double val;
sst >> val;
while (sst.eof()==false)
{
valueList.push_back(val);
sst >> val;
}
return valueList;
}
void TransferForm::initConfig()
{
QString sst(SET_SEC_TRANS);
Setting::lord(sst+SET_KEY_CMBSA, SET_PFX_CMBITM, *m_ui.cmbSrcAddr, false);
Setting::lord(sst+SET_KEY_CMBDA, SET_PFX_CMBITM, *m_ui.cmbDstAddr);
Setting::lord(sst+SET_KEY_CMBSP, SET_PFX_CMBITM, *m_ui.cmbSrcPort);
Setting::lord(sst+SET_KEY_CMBDP, SET_PFX_CMBITM, *m_ui.cmbDstPort);
QString skl(SET_SEC_DIR); skl += SET_KEY_LOG;
skl = Setting::get(skl, SET_KEY_TRANS, SET_VAL_LGTAN);
setProperty(SET_SEC_DIR, skl);
TK::initNetworkInterfaces(m_ui.cmbSrcAddr, true);
TK::initNetworkInterfaces(m_ui.cmbDstAddr);
}
std::vector< std::wstring >
SharedStringTable::parse( Record & record )
{
int totalStrings = 0;
int uniqueStrings = 0;
record.dataStream().read( totalStrings, 4 );
record.dataStream().read( uniqueStrings, 4 );
std::vector< std::wstring > sst( uniqueStrings );
if(MAX_SST_SIZE)
uniqueStrings = min(MAX_SST_SIZE, uniqueStrings) ;
for( int i = 0; i < uniqueStrings; ++i )
sst[ i ] = loadString( record.dataStream(), record.borders() );
return sst;
}
// build a set of SPECULATION_CNT graphs, each of which consists of a broadcast_node,
// xranges x yranges function_nodes, and one queue_node for output.
// once speculation starts, if i % SPECULATION_CNT is the current graph, (i+1) % SPECULATION_CNT
// is the first speculation, and so on.
void
build_BMU_graph(SOMap &map1) {
// build current graph
xsize = ((int)map1.size() + xranges - 1) / xranges;
ysize = ((int)map1[0].size() + yranges - 1) / yranges;
function_node_execs.clear();
function_node_execs.reserve(xranges*yranges+1);
for(int ii = 0; ii < xranges*yranges+1;++ii) function_node_execs.push_back(0);
for(int scnt = 0; scnt < SPECULATION_CNT; ++scnt) {
g[scnt] = new graph;
send_to[scnt] = new b_node(*(g[scnt])); // broadcast node to the function_nodes
q[scnt] = new queue_node<search_result_type>(*(g[scnt])); // output queue
// create the function_nodes, tie to the graph
s_array[scnt] = new search_node_array_type;
s_array[scnt]->reserve(xranges);
g_array[scnt] = new graph_array_type;
g_array[scnt]->reserve(xranges);
for(int i = 0; i < (int)map1.size(); i += xsize) {
int xindex = i / xsize;
s_array[scnt]->push_back(search_node_vector_type());
(*s_array[scnt])[xindex].reserve(yranges);
g_array[scnt]->push_back(graph_vector_type());
(*g_array[scnt])[xindex].reserve(yranges);
for( int j = 0; j < (int)map1[0].size(); j += ysize) {
int offset = (i/xsize)*yranges + (j / ysize);
int xmax = (i + xsize) > (int)map1.size() ? (int)map1.size() : i + xsize;
int ymax = (j + ysize) > (int)map1[0].size() ? (int)map1[0].size() : j + ysize;
subsquare_type sst(i,xmax,1,j,ymax,1);
BMU_search_body bb(map1,sst,function_node_execs[offset]);
graph *g_local = new graph;
search_node *s = new search_node(*g_local, serial, bb); // copies Body
(*g_array[scnt])[xindex].push_back(g_local);
(*s_array[scnt])[xindex].push_back(s);
make_edge(*(send_to[scnt]), *s); // broadcast_node -> function_node
make_edge(*s, *(q[scnt])); // function_node -> queue_node
}
}
}
}
//_________________________________________________________________
void SelectPPCoincMapRegions::SlaveBegin(TTree* /*tree*/)
{
#ifdef DEBUG
std::cout << "slave begin" << std::endl;
#endif
TH1::SetDefaultSumw2(true);
TString option = GetOption();
std::map<UInt_t,TH1D*>::iterator it;
it=regional_coinc.begin();
UInt_t i;
std::ostringstream ss("",std::ios::out | std::ios::app);
std::ostringstream sst("",std::ios::out | std::ios::app);
for (; it!=regional_coinc.end(); it++)
{
ss.str("mult"); ss << fChLow << "to" << fChHigh << "_" << it->first;
sst.str("Multiplicity "); sst << it->first;
sst << ": Chs. " << fChLow << " to " << fChHigh;
sst << " Events;Multiplicity Mask; Counts";
it->second = new TH1D(ss.str().data(),
ss.str().data(),
regional_coinc_map[it->first].size(),
0,
regional_coinc_map[it->first].size());
std::set<std::string>::reverse_iterator it2 = regional_coinc_map[it->first].rbegin();
// std::cout << "\nMultiplicity " << it->first;
// std::cout << "\n--------------------" << std::endl;
for (UInt_t j=1; j<=it->second->GetNbinsX(); j++, it2++)
{
// std::cout << j << "\t" << *it2 << std::endl;
it->second->GetXaxis()->SetBinLabel(j,it2->data());
}
}
}
int main() {
scanf("%d", &t);
while (t--) {
initialize();
sort(edge, edge + m);
kruskal();
for (int i = 1; i <= n; i++) {
int s = adj[i].size(), w;
memset(check, false, sizeof(check));
check[i] = true;
for (int j = 0; j < s; j++) {
w = adj[i][j].w;
dfs(w, i, 0, adj[i][j].val);
}
}
if (sst())
printf("%d\n", mst);
else
printf("Not Unique!\n");
}
return 0;
}
