void MprisControlPlugin::seeked(qlonglong position){
//qCDebug(KDECONNECT_PLUGIN_MPRIS) << "Seeked in player";
NetworkPackage np(PACKAGE_TYPE_MPRIS);
np.set("pos", position/1000); //Send milis instead of nanos
OrgFreedesktopDBusPropertiesInterface* interface = (OrgFreedesktopDBusPropertiesInterface*)sender();
const QString& service = interface->service();
const QString& player = playerList.key(service);
np.set("player", player);
sendPackage(np);
}
void Flowfield::draw () {
for( int z = 0; z < flowList.size(); z++){
for( int y = 0; y < flowList[z].size(); y++){
for( int x=0; x<flowList[z][y].size(); x++){
ofVec3f np( x*resolution, y*resolution, z*resolution );
ofLine ( np, np+flowList[z][y][x] );
}
}
}
}
int main(int argc, char **argv) {
ros::init(argc, argv,"feature_extraction");
ros::NodeHandle n;
ros::NodeHandle np("~");
yagokoro_recognition::FeatureExtraction fe(n, np);
ros::spin();
return 0;
}
// called from ---CPU--- thread
bool NetPlay::GetNetPads(const u8 pad_nb, const SPADStatus* const pad_status, NetPad* const netvalues)
{
{
std::lock_guard<std::recursive_mutex> lkp(m_crit.players);
// in game mapping for this local pad
unsigned int in_game_num = m_local_player->pad_map[pad_nb];
// does this local pad map in game?
if (in_game_num < 4)
{
NetPad np(pad_status);
// adjust the buffer either up or down
// inserting multiple padstates or dropping states
while (m_pad_buffer[in_game_num].Size() <= m_target_buffer_size)
{
// add to buffer
m_pad_buffer[in_game_num].Push(np);
// send
SendPadState(pad_nb, np);
}
}
} // unlock players
//Common::Timer bufftimer;
//bufftimer.Start();
// get padstate from buffer and send to game
while (!m_pad_buffer[pad_nb].Pop(*netvalues))
{
// wait for receiving thread to push some data
Common::SleepCurrentThread(1);
if (false == m_is_running)
return false;
// TODO: check the time of bufftimer here,
// if it gets pretty high, ask the user if they want to disconnect
}
//u64 hangtime = bufftimer.GetTimeElapsed();
//if (hangtime > 10)
//{
// std::ostringstream ss;
// ss << "Pad " << (int)pad_nb << ": Had to wait " << hangtime << "ms for pad data. (increase pad Buffer maybe)";
// Core::DisplayMessage(ss.str(), 1000);
//}
return true;
}
int main( int nargs , char *args[] ) {
nestedParallel np( &nargs , &args );
std::cout << "My rank = " << np.getMyRank() << " ";
std::cout << np.getMyDOTColor() << " ";
if( np.getMyDistributedMemoryMPIComm() != MPI_COMM_NULL )
std::cout << " distributed node ";
else
std::cout << " non-dist node ";
std::cout << "Shared memory mpi_comm_rank = " << np.getMyRankInSharedMemoryComm() << "\n";
return 0;
}
void testEnableIf()
{
SimpleStruct s;
s.x = 10;
SimpleStruct* pCopy = copy(s);
NonPodStruct np(2);
NonPodStruct* pNonCopy = copy(np);
}
uORB::DeviceNode *uORB::DeviceMaster::GetDeviceNode(const char *nodepath)
{
uORB::DeviceNode *rc = nullptr;
std::string np(nodepath);
if (_node_map.find(np) != _node_map.end()) {
rc = _node_map[np];
}
return rc;
}
void graph::ucs(const std::string& v1, const std::string& v2,
std::ofstream& fp, std::ofstream& fl,
double (graph::* cost_f) (unsigned, unsigned) const) const
{
unsigned i1 = get_index(v1);
unsigned i2 = get_index(v2);
ucs_node_queue q;
std::set<unsigned> e;
std::vector<unsigned> t(1, i1);
q.insert(ucs_node(i1, t, 0));
while (!q.empty()) {
ucs_node n = *q.begin();
fl << m_names[n.m_vertex] << "\n";
q.erase(q.begin());
if (n.m_vertex == i2) {
for (unsigned j = 0; j < n.m_path.size(); ++j) {
fp << m_names[n.m_path[j]] << "\n";
}
return;
}
e.insert(n.m_vertex);
std::vector<unsigned>::const_iterator i;
for (i = m_adjacent_vertices[n.m_vertex].begin(); i != m_adjacent_vertices[n.m_vertex].end(); ++i) {
if (e.find(*i) == e.end()) {
ucs_node_queue::iterator qi = find_in_queue(q, *i);
if (qi == q.end()) {
std::vector<unsigned> np(n.m_path);
np.push_back(*i);
q.insert(ucs_node(*i, np, n.m_cost + (this->*cost_f)(n.m_vertex, *i)));
} else {
if (n.m_cost + (this->*cost_f)(n.m_vertex, *i) < qi->m_cost) {
q.erase(qi);
std::vector<unsigned> np(n.m_path);
np.push_back(*i);
q.insert(ucs_node(*i, np, n.m_cost + (this->*cost_f)(n.m_vertex, *i)));
}
}
}
}
}
}
static int
auth_user_pass_verify (struct plugin_context *context, struct plugin_per_client_context *pcc, const char *argv[], const char *envp[])
{
if (context->test_deferred_auth)
{
/* get username/password from envp string array */
const char *username = get_env ("username", envp);
const char *password = get_env ("password", envp);
/* get auth_control_file filename from envp string array*/
const char *auth_control_file = get_env ("auth_control_file", envp);
printf ("DEFER u='%s' p='%s' acf='%s'\n",
np(username),
np(password),
np(auth_control_file));
/* Authenticate asynchronously in n seconds */
if (auth_control_file)
{
char buf[256];
int auth = 2;
sscanf (username, "%d", &auth);
snprintf (buf, sizeof(buf), "( sleep %d ; echo AUTH %s %d ; echo %d >%s ) &",
context->test_deferred_auth,
auth_control_file,
auth,
pcc->n_calls < auth,
auth_control_file);
printf ("%s\n", buf);
system (buf);
pcc->n_calls++;
return OPENVPN_PLUGIN_FUNC_DEFERRED;
}
else
return OPENVPN_PLUGIN_FUNC_ERROR;
}
else
return OPENVPN_PLUGIN_FUNC_SUCCESS;
}
void MuseScore::registerPlugin(const QString& pluginPath)
{
QFileInfo np(pluginPath);
QString baseName = np.baseName();
foreach(QString s, plugins) {
QFileInfo fi(s);
if (fi.baseName() == baseName) {
if (MScore::debugMode)
qDebug(" Plugin <%s> already registered\n", qPrintable(pluginPath));
return;
}
}
int main(int argc, char * argv[]){
ros::init(argc, argv, "nice_predictor");
ros::NodeHandle n;
nice_predictor::NicePredictor np(n);
np.nodeLoop();
return 0;
}
uORB::DeviceNode *uORB::DeviceMaster::GetDeviceNode(const char *nodepath)
{
uORB::DeviceNode *rc = nullptr;
std::string np(nodepath);
auto iter = _node_map.find(np);
if (iter != _node_map.end()) {
rc = iter->second;
}
return rc;
}
void NodelControlReceiverTest::run() throw(std::runtime_error)
{
ModelControlSenderNet mcsn;
DummyReceiver bla;
MyNetProtocol np(mcsn);
ModelControlReceiverNet mcrn(np);
mcsn.registerModelControlReceiver(bla);
mcrn.addModule("testname");
if (bla.name != "testname")
throw std::runtime_error("Wrong error (?)");
}
//I'm in a new network, let's be polite and introduce myself
void LanLinkProvider::onNetworkChange()
{
if (!mTcpServer->isListening()) {
//Not started
return;
}
Q_ASSERT(mTcpPort != 0);
qCDebug(KDECONNECT_CORE()) << "Broadcasting identity packet";
NetworkPackage np("");
NetworkPackage::createIdentityPackage(&np);
np.set("tcpPort", mTcpPort);
mUdpSocket.writeDatagram(np.serialize(), QHostAddress("255.255.255.255"), port);
}
const IV nearest_point_index(const RV & coord)
{
#if 0
IV np(static_cast<int>(floor((coord[0]+.5*lx_)/deltax_)),
static_cast<int>(floor((coord[1]+.5*ly_)/deltay_)),
static_cast<int>(floor((coord[2]+.5*lz_)/deltaz_)));
RV dist=coord-coordinates(np[0],np[1],np[2]);
for(int n=0;n<3;++n)
if(dist[n]>=.5*deltal(n))
np[n]+=1;
return np;
#endif
return IV(static_cast<int>(round((coord[0]+.5*lx_)/deltax_))%nx_,
static_cast<int>(round((coord[1]+.5*ly_)/deltay_))%ny_,
static_cast<int>(round((coord[2]+.5*lz_)/deltaz_))%nz_);
};
void MuseScore::registerPlugin(PluginDescription* plugin)
{
QString pluginPath = plugin->path;
QFileInfo np(pluginPath);
if (np.suffix() != "qml")
return;
QString baseName = np.baseName();
foreach(QString s, plugins) {
QFileInfo fi(s);
if (fi.baseName() == baseName) {
if (MScore::debugMode)
qDebug(" Plugin <%s> already registered\n", qPrintable(pluginPath));
return;
}
}
void handle::pivot(float f, ofVec2f p, ofVec2f t, string jType, string actor){
ofVec2f np(m_posC);
if(jType == "weld"){
np = m_posC.getRotated(f, p, ofVec3f(0,0,1));
t.set(np - m_posC);
m_posC.set(np);
m_rotC += f;
}else if(jType == "pivot"){
if(m_posC != p){
m_posC += t;
}
}
//recursive function call on children
vector <handleJoint>::iterator it = m_children.begin();
while(it != m_children.end()){
if(it->m_handle->getIndex() == actor){++it; continue;} //actor is to prevent double calls
if(it->m_type == "free"){++it; continue;}
if(jType == "weld" && it->m_type == "weld"){
it->m_handle->pivot(f, p, t, "weld", m_index);
}else if(jType == "pivot" || it->m_type == "pivot"){
if(m_posC != p)it->m_handle->pivot(f, p, t, "pivot", m_index);
}
++it;
}
//pivot the parent
if(m_parent){
if(actor != m_parent->getIndex()){
handleJoint hj = m_parent->getChildJoint(m_index);
if(jType == "weld" && hj.m_type == "weld"){
m_parent->pivot(f, p, t, "weld", m_index);
}else if(jType == "pivot" || hj.m_type == "pivot"){
if(m_posC != p)m_parent->pivot(f, p, t, "pivot", m_index);
}
}
}
}
void
pf_context_print(const struct pf_context *pfc, const char *prefix, const int lev)
{
msg(lev, "----- %s : struct pf_context -----", prefix);
if (pfc)
{
msg(lev, "enabled=%d", pfc->enabled);
#ifdef PLUGIN_PF
msg(lev, "filename='%s'", np(pfc->filename));
msg(lev, "file_last_mod=%u", (unsigned int)pfc->file_last_mod);
msg(lev, "n_check_reload=%u", pfc->n_check_reload);
msg(lev, "reload=[%d,%u,%u]", pfc->reload.defined, pfc->reload.n, (unsigned int)pfc->reload.last);
#endif
pf_set_print(pfc->pfs, lev);
}
msg(lev, "--------------------");
}
//**********************************************
void Photon_map :: irradiance_estimate(
float irrad[3], // returned irradiance
const float pos[3], // surface position
const float normal[3], // surface normal at pos
const float max_dist, // max distance to look for photons
const int nphotons ) const // number of photons to use
//**********************************************
{
irrad[0] = irrad[1] = irrad[2] = 0.0;
NearestPhotons np(nphotons+1);
np.pos[0] = pos[0]; np.pos[1] = pos[1]; np.pos[2] = pos[2];
np.max = nphotons;
np.found = 0;
np.got_heap = 0;
np.dist2[0] = max_dist*max_dist;
// locate the nearest photons
locate_photons( &np, 1 );
// if less than 8 photons return
if (np.found<8)
return;
float pdir[3];
// sum irradiance from all photons
for (int i=1; i<=np.found; i++) {
const Photon *p = np.index[i];
// the photon_dir call and following if can be omitted (for speed)
// if the scene does not have any thin surfaces
photon_dir( pdir, p );
if ( (pdir[0]*normal[0]+pdir[1]*normal[1]+pdir[2]*normal[2]) < 0.0f ) {
irrad[0] += p->power[0];
irrad[1] += p->power[1];
irrad[2] += p->power[2];
}
}
const float tmp=(1.0f/M_PI)/(np.dist2[0]); // estimate of density
irrad[0] *= tmp;
irrad[1] *= tmp;
irrad[2] *= tmp;
}
int main(void)
{
int flag;
while(scanf("%d",&num)!=EOF)
{
flag=np(1);
if(1==flag)
{
printf("Stan wins.\n");
}
else
{
printf("Ollie wins.\n");
}
}
return 0;
}
std::vector<double> PMFFilter::morphOpen(PointViewPtr view, float radius)
{
point_count_t np(view->size());
KD2Index index(*view);
index.build();
std::vector<double> minZ(np), maxZ(np);
typedef std::vector<PointId> PointIdVec;
std::map<PointId, PointIdVec> neighborMap;
// erode
for (PointId i = 0; i < np; ++i)
{
double x = view->getFieldAs<double>(Dimension::Id::X, i);
double y = view->getFieldAs<double>(Dimension::Id::Y, i);
auto ids = index.radius(x, y, radius);
// neighborMap.insert(std::pair<PointId, std::vector<PointId>(i, ids));
neighborMap[i] = ids;
double localMin(std::numeric_limits<double>::max());
for (auto const& j : ids)
{
double z = view->getFieldAs<double>(Dimension::Id::Z, j);
if (z < localMin)
localMin = z;
}
minZ[i] = localMin;
}
// dilate
for (PointId i = 0; i < np; ++i)
{
auto ids = neighborMap[i];
double localMax(std::numeric_limits<double>::lowest());
for (auto const& j : ids)
{
double z = minZ[j];
if (z > localMax)
localMax = z;
}
maxZ[i] = localMax;
}
return maxZ;
}
cv::Mat EyeTracker::floodKillEdges(cv::Mat& mat) {
cv::rectangle(mat, cv::Rect(0, 0, mat.cols, mat.rows), 255);
cv::Mat mask(mat.rows, mat.cols, CV_8U, 255);
std::queue<cv::Point> to_do;
to_do.push(cv::Point(0, 0));
auto should_push = [&](cv::Point p) {
return p.x >= 0 && p.x < mat.cols && p.y >= 0 && p.y < mat.rows;
};
while (!to_do.empty()) {
cv::Point p = to_do.front();
to_do.pop();
if (mat.at<float>(p) == 0.0f) {
continue;
}
// right
cv::Point np(p.x + 1, p.y);
if (should_push(np))
to_do.push(np);
// left
np.x = p.x - 1;
np.y = p.y;
if (should_push(np))
to_do.push(np);
// down
np.x = p.x;
np.y = p.y - 1;
if (should_push(np))
to_do.push(np);
// up
np.x = p.x;
np.y = p.y + 1;
if (should_push(np))
to_do.push(np);
mat.at<float>(p) = 0.0f;
mask.at<uchar>(p) = 0;
}
return mask;
}
void FlowField::addCircularForce(float x, float y, float radius, float strength) {
ofVec2f mousePos(x, y);
for( int y=0; y<flowList.size(); y++){
for( int x=0; x<flowList[y].size(); x++){
ofVec2f np( x*resolution, y*resolution );
if( np.distance(mousePos) < radius ){
float pct = 1 - (np.distance(mousePos) / radius);
// add strength towards the mouse
ofVec2f dir = (np - mousePos);
flowList[y][x].x -= dir.normalized().y * strength;
flowList[y][x].y += dir.normalized().x * strength;
}
}
}
}
void graph::dfs(unsigned i1, unsigned i2, std::ofstream& fl, const std::vector<unsigned>& path, std::vector<unsigned>& found_path) const
{
fl << m_names[i1] << "\n";
if (i1 == i2) {
if (found_path.empty() || cost(found_path) > cost(path)) {
found_path = path;
}
return;
}
std::vector<unsigned>::const_reverse_iterator i;
for (i = m_adjacent_vertices[i1].rbegin(); i != m_adjacent_vertices[i1].rend(); ++i) {
if(std::find(path.begin(), path.end(), *i) == path.end()) {
std::vector<unsigned> np(path);
np.push_back(*i);
dfs(*i, i2, fl, np, found_path);
}
}
}
QNapiComplexResult QNapi::bazinga(const QString& movie)
{
QNapiComplexResult res(movie);
QNapiProjektEngine np(movie, m_lang);
res.setNp(np.process());
//qDebug() << movie << "\t|NapiProjekt:\t" << f;
if(res.np() != success)
{
QOpenSubtitlesEngine os(movie, m_lang);
res.setOs(os.process());
// qDebug() << movie << "\t|OpenSubs:\t" << f;
}
return res;
}
void LanLinkProvider::connectError()
{
QSslSocket* socket = qobject_cast<QSslSocket*>(sender());
if (!socket) return;
disconnect(socket, SIGNAL(connected()), this, SLOT(connected()));
disconnect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(connectError()));
qCDebug(KDECONNECT_CORE) << "Fallback (1), try reverse connection (send udp packet)" << socket->errorString();
NetworkPackage np("");
NetworkPackage::createIdentityPackage(&np);
np.set("tcpPort", mTcpPort);
mUdpSocket.writeDatagram(np.serialize(), receivedIdentityPackages[socket].sender, port);
//The socket we created didn't work, and we didn't manage
//to create a LanDeviceLink from it, deleting everything.
delete receivedIdentityPackages.take(socket).np;
delete socket;
}
void generate_bfs(bool** upper,bool** left,Point p,bool** visited,int m,int n,int depth){
queue<Point> pq; //store the visited points in current level
pq.push(p);
visited[p.r][p.c]=true;
int arr[]={0,1,2,3};
while(!pq.empty()){
int size=pq.size();
cout<<"size: "<<size<<endl;
while(size--)
{
Point p=pq.front();
shuffle(arr);
for(int i=0;i<4;i++)
{
int d=arr[i];
//for each point, walk depth steps
int dps=depth;
Point np(p.r,p.c);
while(dps)
{
dps--;
np.r+=dr[d];
np.c+=dc[d];
if(np.r>=0 && np.r<m && np.c>=0 && np.c<n && !visited[np.r][np.c])
{
visited[np.r][np.c]=true;
// if(dps==0)
pq.push(np);
carve(upper, left, np.r, np.c, d);
}else
break;
d=rand()%4;
}//while
}//for
pq.pop();
}
}
}
void NodeImporter::importCities(const std::string& seedString) {
/*
READ CITY POSITIONS ON EARTH SURFACE
*/
Config_Ptr config(new Config);
Config_Ptr cityFilterConfig(config->subConfig("cityfilter"));
int populationThreshold = cityFilterConfig->get<int>("citysizethreshold");
auto lr = std::make_shared<SQLiteLocationReader>(_dbFilename, populationThreshold);
typedef std::map<std::string, std::vector<CityNode>> CountryMap;
std::unique_ptr<CountryMap> countries(new CountryMap);
while (lr->hasNext()) {
CityNode next = lr->getNext();
(*countries)[next.country()].push_back(next);
}
std::unique_ptr<InternetUsageStatistics> stat(new InternetUsageStatistics(_dbFilename));
typedef std::mt19937_64 RNG;
std::seed_seq seed(seedString.begin(), seedString.end());
std::unique_ptr<RNG> randGen(new RNG);
randGen->seed(seed);
std::uniform_real_distribution<double> dist(0.0, 1.0);
// filter cities
for (auto country : *countries) {
std::string countryName = country.first;
auto& cityVec = country.second;
double percentInetUsers = (*stat)[countryName] / 100.0;
for (auto city : cityVec)
if (dist(*randGen) <= percentInetUsers) {
city.setId(_nodenumber);
++_nodenumber;
GeographicNode_Ptr np(new CityNode(city));
addNode(np);
}
}
}
void FlowField::addRepelForce(float x, float y, float radius, float strength) {
ofVec2f mousePos(x, y);
for( int y=0; y<flowList.size(); y++){
for( int x=0; x<flowList[y].size(); x++){
ofVec2f np( x*resolution, y*resolution );
if( np.distance(mousePos) < radius ){
float pct = 1 - (np.distance(mousePos) / radius);
// add strength in the direction it's already moving in
// flowList[y][x] += flowList[y][x].normalized() * strength;
// add strength away from the mouse
ofVec2f dir = (np - mousePos);
flowList[y][x] += dir.normalized() * strength;
}
}
}
}
//I'm in a new network, let's be polite and introduce myself
void LanLinkProvider::broadcastToNetwork()
{
if (!mServer->isListening()) {
//Not started
return;
}
Q_ASSERT(mTcpPort != 0);
qCDebug(KDECONNECT_CORE()) << "Broadcasting identity packet";
QHostAddress destAddress = mTestMode? QHostAddress::LocalHost : QHostAddress(QStringLiteral("255.255.255.255"));
NetworkPackage np(QLatin1String(""));
NetworkPackage::createIdentityPackage(&np);
np.set(QStringLiteral("tcpPort"), mTcpPort);
#ifdef Q_OS_WIN
//On Windows we need to broadcast from every local IP address to reach all networks
QUdpSocket sendSocket;
for (const QNetworkInterface &iface : QNetworkInterface::allInterfaces()) {
if ( (iface.flags() & QNetworkInterface::IsUp)
&& (iface.flags() & QNetworkInterface::IsRunning)
&& (iface.flags() & QNetworkInterface::CanBroadcast)) {
for (const QNetworkAddressEntry &ifaceAddress : iface.addressEntries()) {
QHostAddress sourceAddress = ifaceAddress.ip();
if (sourceAddress.protocol() == QAbstractSocket::IPv4Protocol && sourceAddress != QHostAddress::LocalHost) {
qCDebug(KDECONNECT_CORE()) << "Broadcasting as" << sourceAddress;
sendSocket.bind(sourceAddress, PORT);
sendSocket.writeDatagram(np.serialize(), destAddress, PORT);
sendSocket.close();
}
}
}
}
#else
mUdpSocket.writeDatagram(np.serialize(), destAddress, PORT);
#endif
}
