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;
}
