void SeedListGenerator::generateSeedList(vector<PeptideIdentification>& peptides, SeedList& seeds, bool use_peptide_mass) { seeds.clear(); for (vector<PeptideIdentification>::iterator pep_it = peptides.begin(); pep_it != peptides.end(); ++pep_it) { double mz; if (!pep_it->getHits().empty() && use_peptide_mass) { pep_it->sort(); const PeptideHit& hit = pep_it->getHits().front(); Int charge = hit.getCharge(); mz = hit.getSequence().getMonoWeight(Residue::Full, charge) / double(charge); } else { mz = pep_it->getMZ(); } DPosition<2> point(pep_it->getRT(), mz); seeds.push_back(point); } }
void SeedListGenerator::convertSeedList(const FeatureMap& features, SeedList& seeds) { seeds.clear(); for (FeatureMap::ConstIterator feat_it = features.begin(); feat_it != features.end(); ++feat_it) { DPosition<2> point(feat_it->getRT(), feat_it->getMZ()); seeds.push_back(point); } }
void SeedListGenerator::generateSeedList(const MSExperiment<>& experiment, SeedList& seeds) { seeds.clear(); for (MSExperiment<>::ConstIterator exp_it = experiment.begin(); exp_it != experiment.end(); ++exp_it) { if (exp_it->getMSLevel() == 2) // MS2 spectrum -> look for precursor { MSExperiment<>::ConstIterator prec_it = experiment.getPrecursorSpectrum(exp_it); const vector<Precursor>& precursors = exp_it->getPrecursors(); DPosition<2> point(prec_it->getRT(), precursors[0].getMZ()); seeds.push_back(point); } } }
/*----------------------------------------------------------------------- */ SEXP watershed (SEXP x, SEXP _tolerance, SEXP _ext) { SEXP res; int im, i, j, nx, ny, nz, ext, nprotect = 0; double tolerance; nx = INTEGER ( GET_DIM(x) )[0]; ny = INTEGER ( GET_DIM(x) )[1]; nz = getNumberOfFrames(x,0); tolerance = REAL( _tolerance )[0]; ext = INTEGER( _ext )[0]; PROTECT ( res = Rf_duplicate(x) ); nprotect++; int * index = new int[ nx * ny ]; for ( im = 0; im < nz; im++ ) { double * src = &( REAL(x)[ im * nx * ny ] ); double * tgt = &( REAL(res)[ im * nx * ny ] ); /* generate pixel index and negate the image -- filling wells */ for ( i = 0; i < nx * ny; i++ ) { tgt[ i ] = -src[ i ]; index[ i ] = i; } /* from R includes R_ext/Utils.h */ /* will resort tgt as well */ rsort_with_index( tgt, index, nx * ny ); /* reassign tgt as it was reset above but keep new index */ for ( i = 0; i < nx * ny; i++ ) tgt[ i ] = -src[ i ]; SeedList seeds; /* indexes of all seed starting points, i.e. lowest values */ IntList equals; /* queue of all pixels on the same gray level */ IntList nb; /* seed values of assigned neighbours */ int ind, indxy, nbseed, x, y, topseed = 0; IntList::iterator it; TheSeed newseed; PointXY pt; bool isin; /* loop through the sorted index */ for ( i = 0; i < nx * ny && src[ index[i] ] > BG; ) { /* pool a queue of equally lowest values */ ind = index[ i ]; equals.push_back( ind ); for ( i = i + 1; i < nx * ny; ) { if ( src[ index[i] ] != src[ ind ] ) break; equals.push_back( index[i] ); i++; } while ( !equals.empty() ) { /* first check through all the pixels if we can assign them to * existing objects, count checked and reset counter on each assigned * -- exit when counter equals queue length */ for ( j = 0; j < (int) equals.size(); ) { if ((j%1000)==0) R_CheckUserInterrupt(); ind = equals.front(); equals.pop_front(); /* check neighbours: * - if exists one, assign * - if two or more check what should be combined and assign to the steepest * - if none, push back */ /* reset j to 0 every time we assign another pixel to restart the loop */ nb.clear(); pt = pointFromIndex( ind, nx ); /* determine which neighbour we have, push them to nb */ for ( x = pt.x - ext; x <= pt.x + ext; x++ ) for ( y = pt.y - ext; y <= pt.y + ext; y++ ) { if ( x < 0 || y < 0 || x >= nx || y >= ny || (x == pt.x && y == pt.y) ) continue; indxy = x + y * nx; nbseed = (int) tgt[ indxy ]; if ( nbseed < 1 ) continue; isin = false; for ( it = nb.begin(); it != nb.end() && !isin; it++ ) if ( nbseed == *it ) isin = true; if ( !isin ) nb.push_back( nbseed ); } if ( nb.size() == 0 ) { /* push the pixel back and continue with the next one */ equals.push_back( ind ); j++; continue; } tgt[ ind ] = check_multiple(tgt, src, ind, nb, seeds, tolerance, nx, ny ); /* we assigned the pixel, reset j to restart neighbours detection */ j = 0; } /* now we have assigned all that we could */ if ( !equals.empty() ) { /* create a new seed for one pixel only and go back to assigning neighbours */ topseed++; newseed.index = equals.front(); newseed.seed = topseed; equals.pop_front(); tgt[ newseed.index ] = topseed; seeds.push_back( newseed ); } } // assigning equals } // sorted index /* now we need to reassign indexes while some seeds could be removed */ double * finseed = new double[ topseed ]; for ( i = 0; i < topseed; i++ ) finseed[ i ] = 0; i = 0; while ( !seeds.empty() ) { newseed = seeds.front(); seeds.pop_front(); finseed[ newseed.seed - 1 ] = i + 1; i++; } for ( i = 0; i < nx * ny; i++ ) { j = (int) tgt[ i ]; if ( 0 < j && j <= topseed ) tgt[ i ] = finseed[ j - 1 ]; } delete[] finseed; } // loop through images delete[] index; UNPROTECT (nprotect); return res; }
float ScalarImportance ::estimateNormalizationConstant(const boost::shared_ptr<RandomSequence> &r, const boost::shared_ptr<const Scene> &scene, const boost::shared_ptr<ShadingContext> &context, const boost::shared_ptr<PathMutator> &mutator, const size_t n, FunctionAllocator &allocator, PathSampler::HyperPoint &x, Path &xPath) { float result = 0; Spectrum L; // estimate b typedef std::vector<PathSampler::HyperPoint> SeedList; typedef std::vector<PathSampler::Result> ResultList; ResultList resultList; SeedList seeds; std::vector<float> seedImportance; float I; // XXX fix this PathSampler *sampler = const_cast<PathSampler*>(mutator->getSampler()); for(size_t i = 0; i < n; ++i) { PathSampler::constructHyperPoint(*r, x); // create a Path if(sampler->constructPath(*scene, *context, x, xPath)) { // evaluate the Path resultList.clear(); L = mutator->evaluate(xPath, resultList); I = evaluate(x, xPath, resultList); result += I; seeds.push_back(x); seedImportance.push_back(I); } // end if // free all integrands allocated in this sample context->freeAll(); } // end for i // pick a seed AliasTable<PathSampler::HyperPoint> aliasTable; aliasTable.build(seeds.begin(), seeds.end(), seedImportance.begin(), seedImportance.end()); x = aliasTable((*r)()); Path temp; sampler->constructPath(*scene, *context, x, temp); // copy temp to x temp.clone(xPath, allocator); // free all integrands that were allocated in the estimate context->freeAll(); return result / n; } // end ScalarImportance::estimateNormalizationConstant()