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 discoverComponents(const CDT & ct, const SeedList& seeds) { if (ct.dimension() != 2) return; // tag all faces inside for(typename CDT::All_faces_iterator fit = ct.all_faces_begin(); fit != ct.all_faces_end(); ++fit) fit->set_in_domain(true); // mark "outside" infinite component of the object discoverInfiniteComponent(ct); // mark "outside" components with a seed for(typename SeedList::const_iterator sit = seeds.begin(); sit != seeds.end(); ++sit) { typename CDT::Face_handle fh_loc = ct.locate(*sit); if(fh_loc == NULL || !fh_loc->is_in_domain()) continue; std::list<typename CDT::Face_handle> queue; queue.push_back(fh_loc); while(!queue.empty()) { typename CDT::Face_handle f = queue.front(); queue.pop_front(); f->set_in_domain(false); for(int i = 0; i < 3; ++i) { typename CDT::Face_handle ni = f->neighbor(i); if(ni->is_in_domain() && !ct.is_constrained(typename CDT::Edge(f,i))) //same component { queue.push_back(ni); } } } } }
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); } } }
void SeedListGenerator::convertSeedList(const SeedList& seeds, FeatureMap& features) { features.clear(true); // "true" should really be a default value here... Size counter = 0; for (SeedList::const_iterator seed_it = seeds.begin(); seed_it != seeds.end(); ++seed_it, ++counter) { Feature feature; feature.setRT(seed_it->getX()); feature.setMZ(seed_it->getY()); feature.setUniqueId(counter); features.push_back(feature); } // // assign unique ids: // features.applyMemberFunction(&UniqueIdInterface::setUniqueId); }
double check_multiple( double * tgt, double * src, int & ind, IntList & nb, SeedList & seeds, double & tolerance, int & nx, int & ny ) { if ( nb.size() == 1 ) return nb.front(); if ( nb.size() < 1 ) return 0.0; // dumb protection double diff, maxdiff = 0.0, res = 0.0; int i; IntList::iterator it; SeedList::iterator sit; PointXY ptsit, pt = pointFromIndex( ind, nx ); double distx, dist = FLT_MAX; /* maxdiff */ for ( it = nb.begin(); it != nb.end(); it++ ) { if ( !get_seed( seeds, *it, sit ) ) continue; diff = fabs( src[ ind ] - src[ (*sit).index ] ); if ( diff > maxdiff ) { maxdiff = diff; /* assign result to the steepest until and if it not assigned to closest over the tolerance */ if ( dist == FLT_MAX ) res = *it; } /* we assign to the closest centre which is above tolerance, if none than to maxdiff */ if ( diff >= tolerance ) { ptsit = pointFromIndex( (*sit).index, nx ); distx = distanceXY( pt, ptsit); if ( distx < dist ) { dist = distx; res = * it; } } } /* assign all that need assignment to res, which has maxdiff */ for ( it = nb.begin(); it != nb.end(); it++ ) { if ( *it == res ) continue; if ( !get_seed( seeds, *it, sit ) ) continue; if ( fabs( src[ ind ] - src[ (*sit).index ] ) >= tolerance ) continue; for ( i = 0; i < nx * ny; i++ ) if ( tgt[ i ] == *it ) tgt[ i ] = res; seeds.erase( sit ); } return res; }
/*----------------------------------------------------------------------- */ 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; }
bool get_seed( SeedList & seeds, int & seed, SeedList::iterator & sit ) { for ( sit = seeds.begin(); sit != seeds.end(); sit++ ) if ( (*sit).seed == seed ) return true; return false; }
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()