inline void operator+=(const histogram& hist) { const_iterator it = hist.begin(), e = hist.end(); for (; it != e; ++it) update(it->first, it->second); }
//! apply k-means classify to histogram void apply_k_means_classify(const histogram<double>& input, const std::vector<double>& mu, std::vector<int>& cls ) { int number_of_classes=mu.size(); int i,j,k; //calculate all the classes for(j=0;j<input.size();j++) { int best_k=0; double best_dist=0; for(k=0;k<number_of_classes;k++) { double dist=fabs(input.value(j)-mu[k]); if(dist<best_dist|| best_k==0) { best_dist=dist; best_k=k+1; } } cls[j]=best_k; } }
double ks_distance(const histogram<double>& sample1,const histogram<double>& sample2) { //let's include the whole range double _min=std::min(sample1.min(),sample2.min()); double _max=std::max(sample1.max(),sample2.max()); double _range=_max-_min; histogram<double> _s1(sample1); histogram<double> _s2(sample2); _s1.convert_to_commulative(); _s2.convert_to_commulative(); int _size=std::max(_s1.size(),_s2.size())*2; double _bin=_range/_size; double dist=0.0; double v=0.0; for(int i=0;i<_size;i++,v+=_bin) { double d=fabs(_s1[v]-_s2[v]); if(d>dist) dist=d; } return dist; }
double kl_distance(const histogram<double>& sample1,const histogram<double>& sample2) { //let's include the whole range double _min=std::min(sample1.min(),sample2.min()); double _max=std::max(sample1.max(),sample2.max()); double _range=_max-_min; //now we are going to iterate through samples double distance=0.0; int _size=std::max(sample1.size(),sample2.size()); double _bin=_range/_size; double v=_min+_bin/2.0; for(int i=0;i<_size;i++,v+=_bin) { double _P=0.0; if(v>=sample1.min() && v<=sample1.max()) _P=sample1[v]; double _Q=0.0; if(v>=sample2.min() && v<=sample2.max()) _Q=sample2[v]; if(_P>0.0 && _Q>0.0)//TODO: epsilon? distance+=_P*log(_P/_Q); } return distance; }
/* Add a other histogram to this one. * Does nothing if histogram parameters ( min, max, num_buckets ) don't match. */ void accumulate( const histogram& other ) { if ( min() != other.min() || max() != other.max() || data().size() != other.data().size() ) return; for ( size_t j = 0, num_buckets = _data.size(); j < num_buckets; ++j ) _data[ j ] += other.data()[ j ]; _num_entries += other.num_entries(); }
void compute_histogram(unsigned short *depthimage, int npts, histogram &hist, bool normalize) { hist.clear(); for (int i = 0; i < npts; i++) hist.insert_point(depthimage[i]); if (normalize) hist.normalize(); }
void checkForUniq(const vector<string>& matrix, histogram& hist, vector<Block>& uniqs, int rowSize, int colSize, int numRows, int numCols) { int x = numRows - rowSize + 1; int y = numCols - colSize + 1; for(int i=0;i<x;++i) { for(int j=0;j<y;++j) { hist.init(); hist.evaluate(matrix, i, j, rowSize, colSize); if(hist.isUnique()) { Block blk(i, j, rowSize, colSize); uniqs.push_back(blk); } } } }
static python::dict histogram_array_interface(histogram& self) { python::dict d; python::list shape; for (unsigned i = 0; i < self.dim(); ++i) shape.append(self.shape(i)); if (self.depth() == sizeof(detail::wtype)) { shape.append(2); d["typestr"] = python::str("<f") + python::str(sizeof(double)); } else { d["typestr"] = python::str("<u") + python::str(self.depth()); } d["shape"] = python::tuple(shape); d["data"] = python::make_tuple(reinterpret_cast<boost::uintptr_t>(self.buffer()), false); return d; }
void simple_k_means( histogram<double>& hist, std::vector<double>& mu,int k_means,int maxiter) { std::vector<int> cls(hist.size(),0); if(mu.size()!=k_means) { mu.resize(k_means); //initializing k-means using uniform distribution double vol_min=hist.find_percentile(0.001); double vol_max=hist.find_percentile(0.999); for(int j=0;j<k_means;j++) mu[j]= vol_min+(vol_max-vol_min)*j/(double)(k_means-1); } for(int iter=0;iter<maxiter;iter++) { apply_k_means_classify(hist,mu,cls); estimate_mu(hist,cls,mu); } }
// Run skin-detection algorithm frame detect_skin(const frame& in) { dtn_frame = in; const rgb_byte ZERO = { }; for(int y = HEIGHT - 1; y; --y) { for(int x = WIDTH - 1; x; --x) { auto orig = dtn_frame.get_pixel(x, y); rgb hist_in = { orig[2], orig[1], orig[0] }; if(hist.value(hist_in) < tld) { orig[0] = orig[1] = orig[2] = 0; } } } return dtn_frame; }
//! estimate sample mu using discrete classes void estimate_mu(const histogram<double>& input, const std::vector<int>& cls, std::vector<double>& mu ) { int number_of_classes=mu.size(); int i,j,k; std::vector<double> _counts(number_of_classes,0); for(k=0;k<number_of_classes;k++) mu[k]=0; double _count=0; //1 calculate means for(j=0;j<cls.size();j++) { _count+=input[j]; int _c=cls[j]; if(!_c || _c>number_of_classes) continue; //only use classified voxel _c--; _counts[_c]+=input[j]; mu[_c]+=input[j]*input.value(j); } if(!_count) REPORT_ERROR("No voxels defined in ROI!"); for(k=0;k<number_of_classes;k++) { for(k=0;k<number_of_classes;k++) { if(_counts[k]>0) mu[k]/=_counts[k]; } } }
// protected functions void medianCut::computeBoxInfo(const histogram& hist, boxInfo& theBox) const { // boxInfo.min and .max must be specified before entry and histogram // must be valid. Missing information in boxInfo is computed (mean, // var, colorFrequency, colors) and box boundaries (min,max) are set // to the smallest size, that still encloses all entries in the // specified range of the histogram. int rLow=theBox.min.getRed(); int gLow=theBox.min.getGreen(); int bLow=theBox.min.getBlue(); int rUp=theBox.max.getRed(); int gUp=theBox.max.getGreen(); int bUp=theBox.max.getBlue(); int rMin=rUp,rMax=rLow,gMin=gUp,gMax=gLow,bMin=bUp,bMax=bLow; int i=rLow,j=gLow,k=bLow; int freq; ivector iVec(3); double meanR, meanG, meanB, meanSquareR, meanSquareG, meanSquareB; meanR = meanG = meanB = meanSquareR = meanSquareG = meanSquareB = 0; double accu = 0; theBox.colors = 0; for (i=rLow;i<=rUp;i++) { for (j=gLow;j<=gUp;j++) { for (k=bLow;k<=bUp;k++) { iVec[0]=i; iVec[1]=j; iVec[2]=k; if (hist.at(iVec)>0.0f) { if (k<bMin) {bMin=k;} if (k>bMax) {bMax=k;} if (j<gMin) {gMin=j;} if (j>gMax) {gMax=j;} if (i<rMin) {rMin=i;} if (i>rMax) {rMax=i;} freq = static_cast<const int>(hist.at(iVec)); meanR += freq * i; meanG += freq * j; meanB += freq * k; meanSquareR += freq *i*i; meanSquareG += freq *j*j; meanSquareB += freq *k*k; accu += freq; // Count number of distinct colors theBox.colors++; } } } } meanR /= accu; meanG /= accu; meanB /= accu; meanSquareR /= accu; meanSquareG /= accu; meanSquareB /= accu; // Set minimum and maximum enclosing bounds theBox.min.setRed(rMin); theBox.min.setGreen(gMin); theBox.min.setBlue(bMin); theBox.max.setRed(rMax); theBox.max.setGreen(gMax); theBox.max.setBlue(bMax); // Set number of entries inside box theBox.colorFrequency = static_cast<long int>(accu); // set mean and variance inside box theBox.mean[0] = meanR; theBox.mean[1] = meanG; theBox.mean[2] = meanB; theBox.var[0] = meanSquareR - meanR*meanR; theBox.var[1] = meanSquareG - meanG*meanG; theBox.var[2] = meanSquareB - meanB*meanB; }
void sector_classifier::check_ngram_entropy() { /* Quickly compute the histogram */ /* Scan for a repeating ngram */ for(size_t ngram_size = 1; ngram_size < 20; ngram_size++){ bool ngram_match = true; for(size_t i=ngram_size;i<sbuf.pagesize && ngram_match;i++){ if(sbuf[i%ngram_size]!=sbuf[i]) ngram_match = false; } if(ngram_match){ std::stringstream ss; ss << CONSTANT << "("; for(size_t i=0;i<ngram_size;i++){ char buf[16]; snprintf(buf,sizeof(buf),"0x%02x",sbuf[i]); if(i>0) ss << ' '; ss << buf; } ss << ")"; bulk_fr->write(sbuf.pos0,ss.str(),""); return; // ngram is better than entropy } } /* Couldn't find ngram; check entropy and FF00 counts...*/ size_t ff00_count=0; h.add(sbuf.buf,sbuf.pagesize); h.calc_distribution(); for(size_t i=0;i<sbuf.pagesize-1;i++){ if(sbuf[i]==0xff && sbuf[i+1]==0x00) ff00_count++; } if(sbuf.pagesize<=4096){ // we only tuned for 4096 if(ff00_count>2 && h.unique_counts()>=220){ bulk_fr->write(sbuf.pos0,JPEG,""); return; } } float entropy = h.entropy(); std::stringstream ss; if(entropy>opt_high_entropy){ float cosineVariance = sd_autocorrelation_cosine_variance(); if(debug & DEBUG_INFO) ss << "high entropy ( S=" << entropy << ")" << " ACV= " << cosineVariance << " "; if(cosineVariance > opt_MinimumCosineVariance){ ss << RANDOM; } else { ss << HUFFMAN; } bulk_fr->write(sbuf.pos0,ss.str(),""); } // don't bother recording 'low entropy' unless debuggin if(entropy<=opt_high_entropy && opt_low_entropy) { ss << "low entropy ( S=" << entropy << ")"; if(h.unique_counts() < 5){ ss << " Unique Counts: " << h.unique_counts() << " "; for(std::vector<histogram::hist_element *>::const_iterator it = h.counts.begin();it!=h.counts.end();it++){ ss << (int)((*it)->val) << ":" << (*it)->count << " "; } } } }