int CSVPNet::SetCURLopt(CURL *curl) { //struct curl_slist *headerlist=NULL; //static const char buf[] = "Expect:"; AppSettings& s = AfxGetAppSettings(); char buff[MAX_PATH]; if(s.szOEMTitle.IsEmpty()){ sprintf_s( buff, "SPlayer Build %d", SVP_REV_NUMBER ); }else{ CSVPToolBox svpToolBox; int iDescLen = 0; char *oem = svpToolBox.CStringToUTF8(s.szOEMTitle, &iDescLen); sprintf_s( buff, "SPlayer Build %d OEM%s", SVP_REV_NUMBER ,oem ); free(oem); } char buff_cookie[UNIQU_HASH_SIZE]; memset(buff_cookie,0,UNIQU_HASH_SIZE); { CString path; GetModuleFileName(NULL, path.GetBuffer(MAX_PATH), MAX_PATH); path.ReleaseBuffer(); int Ret = -1; path.MakeLower(); //SVP_LogMsg5(L"got splayer path %s" ,path); if( path.Find(_T("splayer")) >= 0 || path.Find(_T("svplayer")) >= 0 || path.Find(_T("mplayerc")) >= 0 ){ DWORD dwHandle; UINT dwLen; UINT uLen; UINT cbTranslate; LPVOID lpBuffer; dwLen = GetFileVersionInfoSize(path, &dwHandle); TCHAR * lpData = (TCHAR*) malloc(dwLen); if(lpData){ memset((char*)lpData, 0 , dwLen); /* GetFileVersionInfo() requires a char *, but the api doesn't * indicate that it will modify it */ if(GetFileVersionInfo(path, dwHandle, dwLen, lpData) != 0) { CString szParm( _T("\\StringFileInfo\\000004b0\\FileDescription")); if(VerQueryValue(lpData, szParm, &lpBuffer, &uLen) != 0) { CString szProductName((TCHAR*)lpBuffer); //SVP_LogMsg3("szProductName %s", szProductName); szProductName.MakeLower(); if(szProductName.Find(_T("射手")) >= 0 || szProductName.Find(_T("splayer")) >= 0 ){ Ret = 125; } } } } } if(Ret == 125){ //sprintf_s(buff_cookie , UNIQU_HASH_SIZE, "UQID=%s", uniqueIDHash); //curl_easy_setopt(curl, CURLOPT_COOKIE , buff_cookie); }else{ //sprintf_s(buff_cookie , UNIQU_HASH_SIZE, "UQID=%s", uniqueIDHash); //curl_easy_setopt(curl, CURLOPT_COOKIE , buff_cookie); } } curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 1); curl_easy_setopt(curl, CURLOPT_USERAGENT, buff); curl_easy_setopt(curl, CURLOPT_TIMEOUT, 40); curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 20); curl_easy_setopt(curl,CURLOPT_HTTP_VERSION,CURL_HTTP_VERSION_1_0); //must use 1.0 for proxy curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L); //curl_easy_setopt(curl, CURLOPT_SSLVERSION, CURL_SSLVERSION_SSLv2); #if 1 if(iTryID%2 == 0){ DWORD ProxyEnable = 0; CString ProxyServer; DWORD ProxyPort = 0; ULONG len = 256+1; CRegKey key; if( ERROR_SUCCESS == key.Open(HKEY_CURRENT_USER, _T("Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings"), KEY_READ) && ERROR_SUCCESS == key.QueryDWORDValue(_T("ProxyEnable"), ProxyEnable) && ProxyEnable && ERROR_SUCCESS == key.QueryStringValue(_T("ProxyServer"), ProxyServer.GetBufferSetLength(256), &len)) { CStringA p_str("http://"); p_str.Append(CStringA(ProxyServer)); curl_easy_setopt(curl, CURLOPT_PROXY, p_str.GetBuffer());// p_str.ReleaseBuffer(); //curl_easy_setopt(curl, CURLOPT_PROXYPORT, 3128); //p_str.ReleaseBuffer(); //curl_easy_setopt(curl,CURLOPT_PROXYTYPE,CURLPROXY_HTTP_1_0); SVP_LogMsg6("Using proxy %s", p_str); //ProxyServer.ReleaseBufferSetLength(len); }else{ //curl_easy_setopt(curl,CURLOPT_HTTP_VERSION,CURL_HTTP_VERSION_NONE); } } #endif if(fp_curl_verbose){ curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); curl_easy_setopt(curl, CURLOPT_STDERR, fp_curl_verbose); } //SVP_LogMsg5(L"iTryID %d", iTryID); //curl_easy_setopt(curl, CURLOPT_ENCODING, "gzip"); not native supported. so dont use this option // MUST not have this line curl_easy_setopt(curl, CURLOPT_POST, ....); //headerlist = curl_slist_append(headerlist, buf); //WTF ?? //curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist); return 0; }
/* - cli_regcomp_real - interface for parser and compilation */ int /* 0 success, otherwise REG_something */ cli_regcomp_real(regex_t *preg, const char *pattern, int cflags) { struct parse pa; struct re_guts *g; struct parse *p = &pa; int i; size_t len; #ifdef REDEBUG # define GOODFLAGS(f) (f) #else # define GOODFLAGS(f) ((f)&~REG_DUMP) #endif cflags = GOODFLAGS(cflags); if ((cflags®_EXTENDED) && (cflags®_NOSPEC)) return(REG_INVARG); if (cflags®_PEND) { if (preg->re_endp < pattern) return(REG_INVARG); len = preg->re_endp - pattern; } else len = strlen((const char *)pattern); /* do the mallocs early so failure handling is easy */ g = (struct re_guts *)cli_malloc(sizeof(struct re_guts) + (NC-1)*sizeof(cat_t)); if (g == NULL) return(REG_ESPACE); p->ssize = len/(size_t)2*(size_t)3 + (size_t)1; /* ugh */ p->strip = (sop *)cli_calloc(p->ssize, sizeof(sop)); p->slen = 0; if (p->strip == NULL) { free((char *)g); return(REG_ESPACE); } /* set things up */ p->g = g; p->next = (char *)pattern; /* convenience; we do not modify it */ p->end = p->next + len; p->error = 0; p->ncsalloc = 0; for (i = 0; i < NPAREN; i++) { p->pbegin[i] = 0; p->pend[i] = 0; } g->csetsize = NC; g->sets = NULL; g->setbits = NULL; g->ncsets = 0; g->cflags = cflags; g->iflags = 0; g->nbol = 0; g->neol = 0; g->must = NULL; g->mlen = 0; g->nsub = 0; g->ncategories = 1; /* category 0 is "everything else" */ g->categories = &g->catspace[-(CHAR_MIN)]; (void) memset((char *)g->catspace, 0, NC*sizeof(cat_t)); g->backrefs = 0; /* do it */ EMIT(OEND, 0); g->firststate = THERE(); if (cflags®_EXTENDED) p_ere(p, OUT); else if (cflags®_NOSPEC) p_str(p); else p_bre(p, OUT, OUT); EMIT(OEND, 0); g->laststate = THERE(); /* tidy up loose ends and fill things in */ categorize(p, g); stripsnug(p, g); findmust(p, g); g->nplus = pluscount(p, g); g->magic = MAGIC2; preg->re_nsub = g->nsub; preg->re_g = g; preg->re_magic = MAGIC1; #ifndef REDEBUG /* not debugging, so can't rely on the assert() in cli_regexec() */ if (g->iflags®EX_BAD) SETERROR(REG_ASSERT); #endif /* win or lose, we're done */ if (p->error != 0) /* lose */ cli_regfree(preg); return(p->error); }
void IDDecoyProbability::apply_(vector<PeptideIdentification> & ids, const vector<double> & rev_scores, const vector<double> & fwd_scores, const vector<double> & all_scores) { Size number_of_bins(param_.getValue("number_of_bins")); // normalize distribution to [0, 1] vector<double> fwd_scores_normalized(number_of_bins, 0.0), rev_scores_normalized(number_of_bins, 0.0), diff_scores(number_of_bins, 0.0), all_scores_normalized(number_of_bins, 0.0); Transformation_ rev_trafo, fwd_trafo, all_trafo; normalizeBins_(rev_scores, rev_scores_normalized, rev_trafo); normalizeBins_(fwd_scores, fwd_scores_normalized, fwd_trafo); normalizeBins_(all_scores, all_scores_normalized, all_trafo); // rev scores fitting vector<DPosition<2> > rev_data; for (Size i = 0; i < number_of_bins; ++i) { DPosition<2> pos; pos.setX(((double)i) / (double)number_of_bins + 0.0001); // necessary???? pos.setY(rev_scores_normalized[i]); rev_data.push_back(pos); #ifdef IDDECOYPROBABILITY_DEBUG cerr << pos.getX() << " " << pos.getY() << endl; #endif } Math::GammaDistributionFitter gdf; Math::GammaDistributionFitter::GammaDistributionFitResult result_gamma_1st (1.0, 3.0); gdf.setInitialParameters(result_gamma_1st); // TODO heuristic for good start parameters Math::GammaDistributionFitter::GammaDistributionFitResult result_gamma = gdf.fit(rev_data); #ifdef IDDECOYPROBABILITY_DEBUG cerr << gdf.getGnuplotFormula() << endl; String rev_filename = param_.getValue("rev_filename"); generateDistributionImage_(rev_scores_normalized, gdf.getGnuplotFormula(), rev_filename); #endif // generate diffs of distributions // get the fwd and rev distribution, apply all_trafo and calculate the diff vector<Size> fwd_bins(number_of_bins, 0), rev_bins(number_of_bins, 0); double min(all_trafo.min_score), diff(all_trafo.diff_score); Size max_bin(0); for (vector<double>::const_iterator it = fwd_scores.begin(); it != fwd_scores.end(); ++it) { Size bin = (Size)((*it - min) / diff * (double)(number_of_bins - 1)); ++fwd_bins[bin]; if (fwd_bins[bin] > max_bin) { max_bin = fwd_bins[bin]; } } Size max_reverse_bin(0), max_reverse_bin_value(0); //min = rev_trafo.min_score; //diff = rev_trafo.diff_score; for (vector<double>::const_iterator it = rev_scores.begin(); it != rev_scores.end(); ++it) { Size bin = (Size)((*it - min) / diff * (double)number_of_bins); ++rev_bins[bin]; if (rev_bins[bin] > max_bin) { max_bin = rev_bins[bin]; } if (rev_bins[bin] > max_reverse_bin_value) { max_reverse_bin = bin; max_reverse_bin_value = rev_bins[bin]; } } #ifdef IDDECOYPROBABILITY_DEBUG cerr << "Trying to get diff scores" << endl; #endif // get diff of fwd and rev for (Size i = 0; i < number_of_bins; ++i) { Size fwd(0), rev(0); fwd = fwd_bins[i]; rev = rev_bins[i]; if ((double)fwd > (double)(1.3 * rev) && max_reverse_bin < i) { diff_scores[i] = (double)(fwd - rev) / (double)max_bin; } else { diff_scores[i] = 0.0; } } #ifdef IDDECOYPROBABILITY_DEBUG cerr << "Gauss Fitting values size of diff scores=" << diff_scores.size() << endl; #endif // diff scores fitting vector<DPosition<2> > diff_data; double gauss_A(0), gauss_x0(0), norm_factor(0); for (Size i = 0; i < number_of_bins; ++i) { DPosition<2> pos; pos.setX((double)i / (double)number_of_bins); pos.setY(diff_scores[i]); if (pos.getY() > gauss_A) { gauss_A = pos.getY(); } gauss_x0 += pos.getX() * pos.getY(); norm_factor += pos.getY(); diff_data.push_back(pos); } double gauss_sigma(0); gauss_x0 /= (double)diff_data.size(); gauss_x0 /= norm_factor; for (Size i = 0; i <= number_of_bins; ++i) { gauss_sigma += fabs(gauss_x0 - (double)i / (double)number_of_bins); } gauss_sigma /= (double)diff_data.size(); #ifdef IDDECOYPROBABILITY_DEBUG cerr << "setting initial parameters: " << endl; #endif Math::GaussFitter gf; Math::GaussFitter::GaussFitResult result_1st(gauss_A, gauss_x0, gauss_sigma); gf.setInitialParameters(result_1st); #ifdef IDDECOYPROBABILITY_DEBUG cerr << "Initial Gauss guess: A=" << gauss_A << ", x0=" << gauss_x0 << ", sigma=" << gauss_sigma << endl; #endif //TODO: fail-to-fit correction was done using the GNUPlotFormula. Seemed to be a hack. //Changed it to try-catch-block but I am not sure if this correction should be made //at all. Can someone please verify? Math::GaussFitter::GaussFitResult result_gauss (gauss_A, gauss_x0, gauss_sigma); try{ result_gauss = gf.fit(diff_data); } catch(Exception::UnableToFit& /* e */) { result_gauss.A = gauss_A; result_gauss.x0 = gauss_x0; result_gauss.sigma = gauss_sigma; } // // fit failed? // if (gf.getGnuplotFormula() == "") // { // result_gauss.A = gauss_A; // result_gauss.x0 = gauss_x0; // result_gauss.sigma = gauss_sigma; // } #ifdef IDDECOYPROBABILITY_DEBUG cerr << gf.getGnuplotFormula() << endl; String fwd_filename = param_.getValue("fwd_filename"); if (gf.getGnuplotFormula() == "") { String formula("f(x)=" + String(gauss_A) + " * exp(-(x - " + String(gauss_x0) + ") ** 2 / 2 / (" + String(gauss_sigma) + ") ** 2)"); generateDistributionImage_(diff_scores, formula, fwd_filename); } else { generateDistributionImage_(diff_scores, gf.getGnuplotFormula(), fwd_filename); } #endif #ifdef IDDECOYPROBABILITY_DEBUG //all_trafo.diff_score + all_trafo.min_score String gauss_formula("f(x)=" + String(result_gauss.A / all_trafo.max_intensity) + " * exp(-(x - " + String(result_gauss.x0 * all_trafo.diff_score + all_trafo.min_score) + ") ** 2 / 2 / (" + String(result_gauss.sigma * all_trafo.diff_score) + ") ** 2)"); String b_str(result_gamma.b), p_str(result_gamma.p); String gamma_formula = "g(x)=(" + b_str + " ** " + p_str + ") / gamma(" + p_str + ") * x ** (" + p_str + " - 1) * exp(- " + b_str + " * x)"; generateDistributionImage_(all_scores_normalized, all_trafo, gauss_formula, gamma_formula, (String)param_.getValue("fwd_filename")); #endif vector<PeptideIdentification> new_prob_ids; // calculate the probabilities and write them to the IDs for (vector<PeptideIdentification>::const_iterator it = ids.begin(); it != ids.end(); ++it) { if (it->getHits().size() > 0) { vector<PeptideHit> hits; String score_type = it->getScoreType() + "_score"; for (vector<PeptideHit>::const_iterator pit = it->getHits().begin(); pit != it->getHits().end(); ++pit) { PeptideHit hit = *pit; double score = hit.getScore(); if (!it->isHigherScoreBetter()) { score = -log10(score); } hit.setMetaValue(score_type, hit.getScore()); hit.setScore(getProbability_(result_gamma, rev_trafo, result_gauss, fwd_trafo, score)); hits.push_back(hit); } PeptideIdentification id = *it; id.setHigherScoreBetter(true); id.setScoreType(id.getScoreType() + "_DecoyProbability"); id.setHits(hits); new_prob_ids.push_back(id); } } ids = new_prob_ids; }
static PyObject * PyFB_ifstats(PyObject *self) { int mib_ifdata[6] = { CTL_NET, PF_LINK, NETLINK_GENERIC, IFMIB_IFDATA, 0, IFDATA_GENERAL}; struct ifmibdata ifmd; size_t len; int value, i; PyObject *r, *d, *t; len = sizeof value; if (sysctlbyname("net.link.generic.system.ifcount", &value, &len, NULL, 0) < 0) return OSERROR(); r = PyDict_New(); for (i = 1; i <= value; i++) { len = sizeof ifmd; mib_ifdata[4] = i; if (sysctl(mib_ifdata, 6, &ifmd, &len, NULL, 0) < 0) { Py_DECREF(r); PyErr_SetFromErrno(PyExc_OSError); return Py_None; } d = PyDict_New(); #define p_long(f) p(PyLong_FromUnsignedLong, unsigned long, f) #define p_str(f) p(PyString_FromString, char *, f) #define p_int(f) p(PyInt_FromLong, long, f) #define p(adoptor, castor, f) \ t = adoptor((castor)ifmd.ifmd_##f); \ PyDict_SetItemString(d, #f, t); \ Py_DECREF(t); p_str(name); p_int(pcount); p_int(flags); p_int(snd_len); p_int(snd_maxlen); p_int(snd_drops); #undef p #define p(adoptor, castor, f) \ t = adoptor((castor)ifmd.ifmd_data.ifi_##f); \ PyDict_SetItemString(d, #f, t); \ Py_DECREF(t); p_int(type); p_int(physical); p_int(addrlen); p_int(hdrlen); p_int(recvquota); p_int(xmitquota); p_long(mtu); p_long(metric); p_long(baudrate); p_long(ipackets); p_long(ierrors); p_long(opackets); p_long(oerrors); p_long(collisions); p_long(ibytes); p_long(obytes); p_long(imcasts); p_long(omcasts); p_long(iqdrops); p_long(noproto); p_long(hwassist); #undef p PyDict_SetItemString(r, ifmd.ifmd_name, d); Py_DECREF(d); } return r; }
QRgb macGetRgba( QRgb initial, bool *ok, QWidget *parent, const char* ) { Point p = { -1, -1 }; const uchar *pstr = p_str("Choose a color"); static const int sw = 420, sh = 300; if(parent) { parent = parent->topLevelWidget(); p.h = (parent->x() + (parent->width() / 2)) - (sw / 2); p.v = (parent->y() + (parent->height() / 2)) - (sh / 2); QRect r = QApplication::desktop()->screenGeometry(QApplication::desktop()->screenNumber(parent)); if(p.h + sw > r.right()) p.h -= (p.h + sw) - r.right() + 10; if(p.v + sh > r.bottom()) p.v -= (p.v + sh) - r.bottom() + 10; } else if(QWidget *w = qApp->mainWidget()) { static int last_screen = -1; int scr = QApplication::desktop()->screenNumber(w); if(last_screen != scr) { QRect r = QApplication::desktop()->screenGeometry(scr); p.h = (r.x() + (r.width() / 2)) - (sw / 2); p.v = (r.y() + (r.height() / 2)) - (sh / 2); } } RGBColor rgb, rgbout; rgb.red = qRed(initial) * 256; rgb.blue = qBlue(initial) * 256; rgb.green = qGreen(initial) * 256; #if 1 Point place; place.h = p.h == -1 ? 0 : p.h; place.v = p.v == -1 ? 0 : p.v; Boolean rval = FALSE; { QMacBlockingFunction block; QWidget modal_widg(parent, __FILE__ "__modal_dlg", Qt::WType_TopLevel | Qt::WStyle_Customize | Qt::WStyle_DialogBorder); qt_enter_modal(&modal_widg); rval = GetColor(place, pstr, &rgb, &rgbout); qt_leave_modal(&modal_widg); } #else ColorPickerInfo cpInfo; // Set the input color to be an RGB color in system space. cpInfo.theColor.color.rgb.red = rgb.red; cpInfo.theColor.color.rgb.green = rgb.green; cpInfo.theColor.color.rgb.blue = rgb.blue; cpInfo.theColor.profile = 0L; cpInfo.dstProfile = 0L; cpInfo.flags = kColorPickerAppIsColorSyncAware | kColorPickerCanModifyPalette | kColorPickerCanAnimatePalette; // Place dialog cpInfo.placeWhere = kCenterOnMainScreen; if(p.h != -1 || p.v != -1) { cpInfo.placeWhere = kAtSpecifiedOrigin; cpInfo.dialogOrigin = p; } cpInfo.pickerType = 0L; // Use the default picker. cpInfo.eventProc = 0L; cpInfo.colorProc = 0L; cpInfo.colorProcData = 0L; memcpy(cpInfo.prompt, pstr, pstr[0]+1); Boolean rval = FALSE; { QMacBlockingFunction block; rval = (PickColor(&cpInfo) == noErr && cpInfo.newColorChosen); } if(rval) { rval = TRUE; if(!cpInfo.theColor.profile) { rgbout.red = cpInfo.theColor.color.rgb.red; rgbout.green = cpInfo.theColor.color.rgb.green; rgbout.blue = cpInfo.theColor.color.rgb.blue; } else { qDebug("not sure how to handle.."); } } #endif free((void *)pstr); if(ok) (*ok) = rval; if(!rval) return initial; initial = qRgba(rgbout.red / 256, rgbout.green / 256, rgbout.blue / 256, qAlpha(initial)); return initial; }