void DataProcessor::calculateFilterValues(std::vector<int> selectedOptions){ int numSelected = selectedOptions.size(); std::shared_ptr<Histogram> histogram; float mean, standardDeviation, filterMid, filterWidth; _filterValues = glm::vec2(0.0); if(numSelected <= 0) return; if(!_histograms.empty()){ for(int option : selectedOptions){ if(!_useHistogram){ mean = (1.0/_numValues[option])*_sum[option]; standardDeviation = _standardDeviation[option]; histogram = _histograms[option]; filterMid = histogram->highestBinValue(_useHistogram); filterWidth = mean+histogram->binWidth(); filterMid = normalizeWithStandardScore(filterMid, mean, standardDeviation, _normValues); filterWidth = fabs(0.5-normalizeWithStandardScore(filterWidth, mean, standardDeviation, _normValues)); }else{ Histogram hist = _histograms[option]->equalize(); filterMid = hist.highestBinValue(true); std::cout << filterMid << std::endl; filterWidth = 1.f/512.f; } _filterValues += glm::vec2(filterMid, filterWidth); } _filterValues /= numSelected; } }
JSBool JSHistogram_Add(JSContext *cx, unsigned argc, jsval *vp) { if (!argc) { JS_ReportError(cx, "Expected one argument"); return JS_FALSE; } jsval v = JS_ARGV(cx, vp)[0]; if (!(JSVAL_IS_NUMBER(v) || JSVAL_IS_BOOLEAN(v))) { JS_ReportError(cx, "Not a number"); return JS_FALSE; } int32_t value; if (!JS_ValueToECMAInt32(cx, v, &value)) { return JS_FALSE; } if (TelemetryImpl::CanRecord()) { JSObject *obj = JS_THIS_OBJECT(cx, vp); if (!obj) { return JS_FALSE; } Histogram *h = static_cast<Histogram*>(JS_GetPrivate(obj)); if (h->histogram_type() == Histogram::BOOLEAN_HISTOGRAM) h->Add(!!value); else h->Add(value); } return JS_TRUE; }
Inelastic_Event_Generator::~Inelastic_Event_Generator() { msg_Info()<<"In "<<METHOD<<"(out = "<<m_output<<")\n"; if (m_output) { if (m_analyse) { msg_Info() <<"Mean number of number of ladders: " <<"naive = "<<m_histograms[string("N_ladder_naive")]->Average()<<", " <<"start = "<<m_histograms[string("N_ladder_start")]->Average()<<", " <<"prim = "<<m_histograms[string("N_ladder_prim")]->Average()<<", " <<"true = "<<m_histograms[string("N_ladder_true")]->Average()<<".\n"; } msg_Info()<<"Errors: \n" <<" Not able to connect blobs "<<m_connectblobs<<";\n" <<" Wrong colours from ladder "<<m_laddercols<<";\n" <<" Not able to update colours in event "<<m_updatecols<<".\n"; } if (m_histograms.empty() || !m_analyse) return; Histogram * histo; string name; for (map<string,Histogram *>::iterator hit=m_histograms.begin(); hit!=m_histograms.end();hit++) { histo = hit->second; name = string("Ladder_Analysis/")+hit->first+string(".dat"); histo->Finalize(); histo->Output(name); delete histo; } m_histograms.clear(); }
~HistogramFixture() { BOOST_CHECK_EQUAL(h.getNumSamples(), 14); BOOST_CHECK_EQUAL(h.getPercentile(0.5), 5); BOOST_CHECK_EQUAL(h.getPercentile(0.75), 7); BOOST_CHECK_EQUAL(h.getPercentile(0.2), 2); BOOST_CHECK_EQUAL(h.getFraction(2), 3.0/14.0); }
void EqualizeAlgorithm::doAlgorithm(Image& img) { unsigned char * rawData = img.getRawData(); int bpp = img.getBPP(); int height = img.getHeight(); int width = img.getWidth(); int pitch = img.getPitch(); //step 1 //Create the histogram Histogram h; double * histo = h.normalizeHistogram(rawData, bpp, height, width, pitch, size); //step 2 //Modify the histogram for usage double * histoModified = new double[size]; histoModified[0] = histo[0]; unsigned int x, y; for (x = 1; x < size; x++) { histoModified[x] = histoModified[x - 1] + histo[x]; } //step 3 //Change the color values according to the modified histogram for (y = 0; y < height; y++) { for (x = 0; x < pitch; x += bpp) { rawData[y * pitch + x + RED] = histoModified[rawData[y * pitch + x + RED]] * size; rawData[y * pitch + x + GREEN] = histoModified[rawData[y * pitch + x + GREEN]] * size; rawData[y * pitch + x + BLUE] = histoModified[rawData[y * pitch + x + BLUE]] * size; } } }
void SpectrumWidget::showMetaDistribution(const String& name) { Histogram<> dist = createMetaDistribution_(name); HistogramDialog dw(dist); dw.setLegend(name); if (dw.exec() == QDialog::Accepted) { DataFilters filters; if (dw.getLeftSplitter() > dist.minBound()) { DataFilters::DataFilter filter; filter.value = dw.getLeftSplitter(); filter.field = DataFilters::META_DATA; filter.meta_name = name; filter.op = DataFilters::GREATER_EQUAL; filter.value_is_numerical = true; filters.add(filter); } if (dw.getRightSplitter() < dist.maxBound()) { DataFilters::DataFilter filter; filter.value = dw.getRightSplitter(); filter.field = DataFilters::META_DATA; filter.meta_name = name; filter.op = DataFilters::LESS_EQUAL; filter.value_is_numerical = true; filters.add(filter); } canvas_->setFilters(filters); } }
void SpectrumWidget::showIntensityDistribution() { Histogram<> dist = createIntensityDistribution_(); HistogramDialog dw(dist); dw.setLegend("intensity"); dw.setLogMode(true); if (dw.exec() == QDialog::Accepted) { DataFilters filters; if (dw.getLeftSplitter() > dist.minBound()) { DataFilters::DataFilter filter; filter.value = dw.getLeftSplitter(); filter.field = DataFilters::INTENSITY; filter.op = DataFilters::GREATER_EQUAL; filters.add(filter); } if (dw.getRightSplitter() < dist.maxBound()) { DataFilters::DataFilter filter; filter.value = dw.getRightSplitter(); filter.field = DataFilters::INTENSITY; filter.op = DataFilters::LESS_EQUAL; filters.add(filter); } canvas_->setFilters(filters); } }
/** * Compute the histogram of distances between sample points on the shape. The histogram bins uniformly subdivide the range * of distances from zero to \a max_distance. If \a max_distance is negative, the shape scale specified in the constructor * will be used. * * @param histogram The histogram to be computed. * @param dist_type The type of distance metric. * @param max_distance The maximum separation between points to consider for the histogram. A negative value indicates the * entire shape is to be considered (in which case \a max_distance is set to the shape scale specified in the * constructor). The histogram range is set appropriately. * @param pair_reduction_ratio The fraction of the available set of point pairs -- expressed as a number between 0 and 1 -- * that will be randomly selected and used to actually build the histogram. Note that the final set is a subsampling of * the set of all possible pairs, not the set of all possible pairs of a subsampled set of points. This may be useful for * getting a more evenly sampled set of pairwise distances, with an extra-large initial set of points. A value of 1 * indicates all ordered pairs will be used, but this counts every distance twice, so a value of 0.5 or so may be more * appropriate. A negative value picks a default of 0.5, or the ratio that gives a maximum of ~1M ordered pairs, whichever * is smaller. */ void compute(Histogram & histogram, DistanceType dist_type, Real max_distance = -1, Real pair_reduction_ratio = -1) const { long num_samples = ldh.numSamples(); long num_distinct_unordered = (num_samples - 1) * num_samples; if (pair_reduction_ratio < 0) pair_reduction_ratio = (Real)std::min(0.5, 1000000.0 / num_distinct_unordered); // don't count (x, x) histogram.setZero(); // don't bother setting the range Real local_reduction_ratio = std::sqrt(pair_reduction_ratio); long num_queries = Math::clamp((long)std::ceil(local_reduction_ratio * num_samples), 0, num_samples - 1); if (num_queries <= 0) return; TheaArray<int32> query_indices((array_size_t)num_queries); Random::common().sortedIntegers(0, (int32)num_samples - 1, (int32)num_queries, &query_indices[0]); Histogram local_histogram(histogram.numBins()); for (array_size_t i = 0; i < query_indices.size(); ++i) { Vector3 p = ldh.getSamplePosition(query_indices[i]); ldh.compute(p, local_histogram, dist_type, max_distance, local_reduction_ratio); // Remove the zero distance from the query point to itself local_histogram.remove(0.0); if (i == 0) histogram.setRange(local_histogram.minValue(), local_histogram.maxValue()); histogram.insert(local_histogram); } }
NS_IMETHODIMP TelemetryImpl::GetHistogramSnapshots(JSContext *cx, jsval *ret) { JSObject *root_obj = JS_NewObject(cx, NULL, NULL, NULL); if (!root_obj) return NS_ERROR_FAILURE; *ret = OBJECT_TO_JSVAL(root_obj); StatisticsRecorder::Histograms h; StatisticsRecorder::GetHistograms(&h); for (StatisticsRecorder::Histograms::iterator it = h.begin(); it != h.end();++it) { Histogram *h = *it; JSObject *hobj = JS_NewObject(cx, NULL, NULL, NULL); if (!(hobj && JS_DefineProperty(cx, root_obj, h->histogram_name().c_str(), OBJECT_TO_JSVAL(hobj), NULL, NULL, JSPROP_ENUMERATE) && ReflectHistogramSnapshot(cx, hobj, h))) { return NS_ERROR_FAILURE; } } MutexAutoLock hashMutex(mHashMutex); // Add info about slow SQL queries on the main thread if (!AddSlowSQLInfo(cx, root_obj, true)) return NS_ERROR_FAILURE; // Add info about slow SQL queries on other threads if (!AddSlowSQLInfo(cx, root_obj, false)) return NS_ERROR_FAILURE; return NS_OK; }
/** * Compute the histogram of euclidean distances from a query point to sample points on the shape. The histogram bins * uniformly subdivide the range of distances from zero to \a max_distance. If \a max_distance is negative, the shape scale * specified in the constructor will be used. * * @param position The position of the query point. * @param histogram The histogram to be computed. * @param max_distance The distance to the furthest point to consider for the histogram. A negative value indicates the * entire shape is to be considered (in which case \a max_distance is set to the shape scale specified in the * constructor). The histogram range is set appropriately. * @param sample_reduction_ratio The fraction of the available set of samples -- expressed as a number between 0 and 1 -- * that will be randomly selected and used to actually build the histogram. This may be useful for getting a more evenly * sampled set of pairwise distances when calling this function with multiple query points (and an extra-large initial set * of points). A negative value, or a value of 1, indicates all sample points will be used. */ void computeGeodesic(Vector3 const & position, Histogram & histogram, Real max_distance, Real sample_reduction_ratio) const { if (sample_reduction_ratio < 0) sample_reduction_ratio = 1.1; // play safe bool process_all = (max_distance < 0); if (process_all) max_distance = this->getNormalizationScale(); histogram.setRange(0, std::max((double)max_distance, 1.0e-30)); histogram.setZero(); SampleGraph * graph = const_cast<SampleGraph *>(this->getSampleGraph()); alwaysAssertM(graph, "LocalDistanceHistogram: Non-null sample graph required to compute geodesic distances"); // Find the sample closest to the query position and use it as the source for all distance calculations long seed_index = -1; if (this->hasExternalKDTree()) seed_index = this->getMutableExternalKDTree()->template closestElement<MetricL2>(position); else seed_index = this->getMutableInternalKDTree()->template closestElement<MetricL2>(position); alwaysAssertM(seed_index >= 0, "LocalDistanceHistogram: Seed sample for geodesic distances not found"); // Assume the graph and the kd-tree have samples in the same sequence SampleGraph::SurfaceSample * seed_sample = const_cast<SampleGraph::SurfaceSample *>(&graph->getSample(seed_index)); ShortestPaths<SampleGraph> shortest_paths; GeodesicCallback callback(histogram, sample_reduction_ratio); shortest_paths.dijkstraWithCallback(*graph, seed_sample, &callback, (process_all ? -1 : max_distance)); }
void VectorTest::test_calculate_bin(void) { message += "test_calculate_bin\n"; Vector<double> v; size_t bin; Histogram<double> histogram; v.set(0.0, 1.0, 9.0); histogram = v.calculate_histogram(10); // Test bin = histogram.calculate_bin(v[0]); assert_true(bin == 0, LOG); // Test bin = histogram.calculate_bin(v[1]); assert_true(bin == 1, LOG); // Test bin = histogram.calculate_bin(v[2]); assert_true(bin == 2, LOG); }
/** * Compute the histogram of euclidean distances from a query point to sample points on the shape. The histogram bins * uniformly subdivide the range of distances from zero to \a max_distance. If \a max_distance is negative, the shape scale * specified in the constructor will be used. * * @param position The position of the query point. * @param histogram The histogram to be computed. * @param max_distance The distance to the furthest point to consider for the histogram. A negative value indicates the * entire shape is to be considered (in which case \a max_distance is set to the shape scale specified in the * constructor). The histogram range is set appropriately. * @param sample_reduction_ratio The fraction of the available set of samples -- expressed as a number between 0 and 1 -- * that will be randomly selected and used to actually build the histogram. This may be useful for getting a more evenly * sampled set of pairwise distances when calling this function with multiple query points (and an extra-large initial set * of points). A negative value, or a value of 1, indicates all sample points will be used. */ void computeEuclidean(Vector3 const & position, Histogram & histogram, Real max_distance, Real sample_reduction_ratio) const { if (sample_reduction_ratio < 0) sample_reduction_ratio = 1.1; // play safe bool process_all = (max_distance < 0); if (process_all) max_distance = this->getNormalizationScale(); histogram.setRange(0, std::max((double)max_distance, 1.0e-30)); histogram.setZero(); EuclideanCallback callback(position, histogram, sample_reduction_ratio); if (process_all) { long num_samples = this->numSamples(); for (long i = 0; i < num_samples; ++i) callback(i, this->getSamplePosition(i)); } else { Ball3 ball(position, max_distance); if (this->hasExternalKDTree()) this->getMutableExternalKDTree()->template processRangeUntil<IntersectionTester>(ball, &callback); else this->getMutableInternalKDTree()->template processRangeUntil<IntersectionTester>(ball, &callback); } }
void Application::computeRatios(const BOOM::String &filestem, Histogram<double> &posHist, Histogram<double> &backgroundHist, double minScore, double maxScore,int numBins) { BOOM::String outfile=filestem+".isp"; ofstream os(outfile.c_str()); double binSize=(maxScore-minScore)/numBins; os<<minScore<<"\t"<<maxScore<<"\t"<<numBins<<"\t"<<binSize<<endl; double sum=posHist.sum(); for(int i=0 ; i<numBins ; ++i) { double x=minScore+i*binSize; //double numerator=posHist.getBin(i); //double denominator=backgroundHist.getBin(i); double numerator=posHist.getBin(i)/sum; //(posHist.getBin(i)+backgroundHist.getBin(i)); double denominator=1-numerator; double r=denominator ? numerator/denominator : 1; //os<<x<<"\t"<<r<<"\t"<<posHist.getBin(i)<<"\t"<<backgroundHist.getBin(i)<<endl; os<<x<<"\t"<<(x+binSize)<<"\t"<<log(r)<<endl; } cout<<"Ratios written into "<<outfile<<endl; }
TEST(Histogram, testBinarization) { G12Buffer *image = BufferFactory::getInstance()->loadG12Bitmap("data/pair/image0001_c0.pgm"); CORE_ASSERT_TRUE(image != NULL, "missed testBinarization input data"); Histogram *histogram = new Histogram(image); int meanLevel = histogram->getMeanThreshold(); int medianLevel = histogram->getMedianThreshold(); int otsuLevel = histogram->getOtsuThreshold(); G12Buffer *meanImage = image->binarize(meanLevel); BMPLoader().save("mean.bmp", meanImage); G12Buffer *medianImage = image->binarize(medianLevel); BMPLoader().save("median.bmp", medianImage); G12Buffer *otsuImage = image->binarize(otsuLevel); BMPLoader().save("otsu.bmp", otsuImage); delete otsuImage; delete medianImage; delete meanImage; delete histogram; delete image; }
Histogram<DIM, POS, VAL>::Histogram(const Histogram<DIM, POS, VAL>& histo) : Array<DIM, VAL>(histo) { m_spaceMin = histo.getMinPosition(); m_spaceMax = histo.getMaxPosition(); m_spaceSize = m_spaceMax - m_spaceMin; }
int main() { int sizeArr; cout << "enter array size: " << endl; cin >> sizeArr; Histogram *pMyHistogram = new Histogram(sizeArr); pMyHistogram->showHistogram(sizeArr); }
/** * Performs cubic spline interpolation from input to output * @param input A histogram from which to interpolate * @param output A histogram where to store the interpolated values */ void interpolateCSplineInplace(const Histogram &input, Histogram &output) { sanityCheck(input, output, minSizeForCSplineInterpolation()); const auto &points = input.points().rawData(); const auto &y = input.y().rawData(); const auto &interpPoints = output.points(); auto &newY = output.mutableY(); interpolateInplace(points, y, interpPoints, newY, InterpolationType::CSPLINE); }
Histogram<> Spectrum1DWidget::createMetaDistribution_(const String& name) const { Histogram<> tmp; //float arrays const ExperimentType::SpectrumType::FloatDataArrays& f_arrays = (*canvas_->getCurrentLayer().getPeakData())[0].getFloatDataArrays(); for (ExperimentType::SpectrumType::FloatDataArrays::const_iterator it = f_arrays.begin(); it != f_arrays.end(); ++it) { if (it->getName() == name) { //determine min and max of the data float min = numeric_limits<float>::max(), max = -numeric_limits<float>::max(); for (Size i = 0; i < it->size(); ++i) { if ((*it)[i] < min) min = (*it)[i]; if ((*it)[i] > max) max = (*it)[i]; } if (min >= max) return tmp; //create histogram tmp.reset(min, max, (max - min) / 500.0); for (Size i = 0; i < it->size(); ++i) { tmp.inc((*it)[i]); } } } //integer arrays const ExperimentType::SpectrumType::IntegerDataArrays& i_arrays = (*canvas_->getCurrentLayer().getPeakData())[0].getIntegerDataArrays(); for (ExperimentType::SpectrumType::IntegerDataArrays::const_iterator it = i_arrays.begin(); it != i_arrays.end(); ++it) { if (it->getName() == name) { //determine min and max of the data float min = numeric_limits<float>::max(), max = -numeric_limits<float>::max(); for (Size i = 0; i < it->size(); ++i) { if ((*it)[i] < min) min = (*it)[i]; if ((*it)[i] > max) max = (*it)[i]; } if (min >= max) return tmp; //create histogram tmp.reset(min, max, (max - min) / 500.0); for (Size i = 0; i < it->size(); ++i) { tmp.inc((*it)[i]); } } } //fallback if no array with that name exists return tmp; }
NS_IMETHODIMP TelemetryImpl::GetHistogramSnapshots(JSContext *cx, jsval *ret) { JSObject *root_obj = JS_NewObject(cx, NULL, NULL, NULL); if (!root_obj) return NS_ERROR_FAILURE; *ret = OBJECT_TO_JSVAL(root_obj); // Ensure that all the HISTOGRAM_FLAG histograms have been created, so // that their values are snapshotted. for (size_t i = 0; i < Telemetry::HistogramCount; ++i) { if (gHistograms[i].histogramType == nsITelemetry::HISTOGRAM_FLAG) { Histogram *h; DebugOnly<nsresult> rv = GetHistogramByEnumId(Telemetry::ID(i), &h); MOZ_ASSERT(NS_SUCCEEDED(rv)); } }; StatisticsRecorder::Histograms hs; StatisticsRecorder::GetHistograms(&hs); // We identify corrupt histograms first, rather than interspersing it // in the loop below, to ensure that our corruption statistics don't // depend on histogram enumeration order. // // Of course, we hope that all of these corruption-statistics // histograms are not themselves corrupt... IdentifyCorruptHistograms(hs); // OK, now we can actually reflect things. for (HistogramIterator it = hs.begin(); it != hs.end(); ++it) { Histogram *h = *it; if (!ShouldReflectHistogram(h) || IsEmpty(h)) { continue; } JSObject *hobj = JS_NewObject(cx, NULL, NULL, NULL); if (!hobj) { return NS_ERROR_FAILURE; } JS::AutoObjectRooter root(cx, hobj); switch (ReflectHistogramSnapshot(cx, hobj, h)) { case REFLECT_CORRUPT: // We can still hit this case even if ShouldReflectHistograms // returns true. The histogram lies outside of our control // somehow; just skip it. continue; case REFLECT_FAILURE: return NS_ERROR_FAILURE; case REFLECT_OK: if (!JS_DefineProperty(cx, root_obj, h->histogram_name().c_str(), OBJECT_TO_JSVAL(hobj), NULL, NULL, JSPROP_ENUMERATE)) { return NS_ERROR_FAILURE; } } } return NS_OK; }
void theta::randomize_poisson(Histogram & h, Random & rnd){ const size_t nbins = h.get_nbins(); for(size_t bin=0; bin<=nbins+1; ++bin){ double mu = h.get(bin); if(mu > 0.){ h.set(bin, rnd.poisson(mu)); } } }
void estimatePolynomial(const size_t order, const Histogram &histo, const size_t i_min, const size_t i_max, double &out_bg0, double &out_bg1, double &out_bg2, double &out_chisq_red) { const auto &X = histo.points(); const auto &Y = histo.y(); estimate(order, X, Y, i_min, i_max, 0, 0, false, out_bg0, out_bg1, out_bg2, out_chisq_red); }
// ###################################################################### void CenterSurroundHistogramSegmenter::csTemplateSalientRegion (Point2D<int> pt) { Point2D<int> gpt(pt.i/GRID_SIZE, pt.j/GRID_SIZE); Rectangle intRect = itsIntegralHistogram.getBounds(); Timer tim(1000000); tim.reset(); // try the various center surround combination for(uint i = 0; i < itsCStemplates.size(); i++) { Rectangle cR = itsCStemplates[i].first; Rectangle sR = itsCStemplates[i].second; // only use the rectangle part that overlaps the image Rectangle grC = intRect.getOverlap(cR+gpt); Rectangle grS = intRect.getOverlap(sR+gpt); // get the center and surround histograms rutz::shared_ptr<Histogram> hC = getGridHistogramDistribution(grC); rutz::shared_ptr<Histogram> hCS = getGridHistogramDistribution(grS); Histogram hS = (*hCS) - (*hC); // smooth and normalize int npointC = grC.area()*GRID_SIZE*GRID_SIZE; int npointS = grS.area()*GRID_SIZE*GRID_SIZE - npointC; Histogram shC = smoothAndNormalize(*hC, npointC); Histogram shS = smoothAndNormalize( hS, npointS); // get the difference float diff = shS.getChiSqDiff(shC); // update the center surround belief estimation // we store the max as the best estimation of belief for(int ii = grS.left(); ii <= grS.rightI(); ii++) for(int jj = grS.top(); jj <= grS.bottomI(); jj++) { Point2D<int> pt(ii,jj); // if point is in center if(grC.contains(pt)) { float prevC = itsGridCenterBelief.getVal(ii,jj); if(prevC < diff) itsGridCenterBelief.setVal(ii,jj, diff); } // or surround else { float prevS = itsGridSurroundBelief.getVal(ii,jj); if(prevS < diff) itsGridSurroundBelief.setVal(ii,jj, diff); } } } LINFO("time: %f", tim.get()/1000.0F); }
void VectorTest::test_calculate_histogram(void) { message += "test_calculate_histogram\n"; Vector<double> v; Histogram<double> histogram; Vector<double> centers; Vector<size_t> frequencies; // Test v.set(0.0, 1.0, 9.0); histogram = v.calculate_histogram(10); assert_true(histogram.get_bins_number() == 10, LOG); centers = histogram.centers; frequencies = histogram.frequencies; assert_true(fabs(centers[0] - 0.45) < 1.0e-12, LOG); assert_true(fabs(centers[1] - 1.35) < 1.0e-12, LOG); assert_true(fabs(centers[2] - 2.25) < 1.0e-12, LOG); assert_true(fabs(centers[3] - 3.15) < 1.0e-12, LOG); assert_true(fabs(centers[4] - 4.05) < 1.0e-12, LOG); assert_true(fabs(centers[5] - 4.95) < 1.0e-12, LOG); assert_true(fabs(centers[6] - 5.85) < 1.0e-12, LOG); assert_true(fabs(centers[7] - 6.75) < 1.0e-12, LOG); assert_true(fabs(centers[8] - 7.65) < 1.0e-12, LOG); assert_true(fabs(centers[9] - 8.55) < 1.0e-12, LOG); assert_true(frequencies[0] == 1, LOG); assert_true(frequencies[1] == 1, LOG); assert_true(frequencies[2] == 1, LOG); assert_true(frequencies[3] == 1, LOG); assert_true(frequencies[4] == 1, LOG); assert_true(frequencies[5] == 1, LOG); assert_true(frequencies[6] == 1, LOG); assert_true(frequencies[7] == 1, LOG); assert_true(frequencies[8] == 1, LOG); assert_true(frequencies[9] == 1, LOG); assert_true(histogram.frequencies.calculate_sum() == 10, LOG); // Test v.set(20); v.randomize_normal(); histogram = v.calculate_histogram(10); assert_true(histogram.frequencies.calculate_sum() == 20, LOG); }
NS_IMETHODIMP TelemetryImpl::NewHistogram(const nsACString &name, uint32_t min, uint32_t max, uint32_t bucketCount, uint32_t histogramType, JSContext *cx, jsval *ret) { Histogram *h; nsresult rv = HistogramGet(PromiseFlatCString(name).get(), min, max, bucketCount, histogramType, &h); if (NS_FAILED(rv)) return rv; h->ClearFlags(Histogram::kUmaTargetedHistogramFlag); return WrapAndReturnHistogram(h, cx, ret); }
void COpenCVInterfaceDlg::OnToolsHistogram() { if(mainImage.cols) { Histogram dlg; dlg.setHisto(Tools::calcHisto(mainImage)); dlg.DoModal(); } else MessageBox("No image loaded"); }
/** Return the most likely distance between two contigs and the number * of pairs that support that estimate. */ static pair<int, unsigned> maximumLikelihoodEstimate(int first, int last, const Histogram& samples, const PMF& pmf, unsigned len0, unsigned len1) { int filterSize = 2 * (int)(0.05 * pmf.mean()) + 3; // want an odd filter size first = max(first, (int)pmf.minValue() - samples.maximum()) - filterSize/2; last = min(last, (int)pmf.maxValue() - samples.minimum()) + filterSize/2 + 1; /* When randomly selecting fragments that span a given point, * longer fragments are more likely to be selected than * shorter fragments. */ WindowFunction window(len0, len1); unsigned nsamples = samples.size(); double bestLikelihood = -numeric_limits<double>::max(); int bestTheta = first; unsigned bestn = 0; vector<double> le; vector<unsigned> le_n; vector<int> le_theta; for (int theta = first; theta <= last; theta++) { // Calculate the normalizing constant of the PMF, f_theta(x). double c = 0; for (int i = pmf.minValue(); i <= (int)pmf.maxValue(); ++i) c += pmf[i] * window(i - theta); double likelihood; unsigned n; tie(likelihood, n) = computeLikelihood(theta, samples, pmf); likelihood -= nsamples * log(c); le.push_back(likelihood); le_n.push_back(n); le_theta.push_back(theta); } HannWindow filter(filterSize); for (int i = filterSize / 2; i < (int)le.size()-(filterSize / 2); i++) { double likelihood = 0; for (int j = -filterSize / 2; j <= filterSize / 2; j++) { assert((unsigned)(i + j) < le.size() && i + j >= 0); likelihood += filter(j) * le[i + j]; } if (le_n[i] > 0 && likelihood > bestLikelihood) { bestLikelihood = likelihood; bestTheta = le_theta[i]; bestn = le_n[i]; } } return make_pair(bestTheta, bestn); }
cv::Mat ExtractContours::Binarization(cv::Mat image, cv::Mat result) { cv::Mat imageGray = image.clone(); cv::cvtColor(image, imageGray, cv::COLOR_BGR2GRAY); cv::bilateralFilter(imageGray, result, 0, 10, 10); Histogram histo; int nr = histo.Thresh(imageGray); //histograma -> pragul pica unde se termina gausianul cv::threshold(imageGray, result, nr, 255, CV_ADAPTIVE_THRESH_MEAN_C); return result; }
void estimateBackground(const size_t order, const Histogram &histo, const size_t i_min, const size_t i_max, const size_t p_min, const size_t p_max, double &out_bg0, double &out_bg1, double &out_bg2, double &out_chisq_red) { const auto &X = histo.points(); const auto &Y = histo.y(); // fit with a hole in the middle estimate(order, X, Y, i_min, i_max, p_min, p_max, true, out_bg0, out_bg1, out_bg2, out_chisq_red); }
void Histogram<DIM, POS, VAL>::operator-=(const Histogram<DIM, POS, VAL>& i_histo) { if(i_histo.getSize() != this->getSize()) { throw exception::Message("Histogram::operator+= wrong size", STK_DBG_INFO); } for(int i=0; i<this->getArraySize(); i++) { this->getFromIndice(i) -= i_histo.getFromIndice(i); } }
JSBool JSHistogram_Clear(JSContext *cx, unsigned argc, jsval *vp) { JSObject *obj = JS_THIS_OBJECT(cx, vp); if (!obj) { return JS_FALSE; } Histogram *h = static_cast<Histogram*>(JS_GetPrivate(obj)); h->Clear(); return JS_TRUE; }