TGraph* makeSeparationCurve(const TH1* histogram_Z, const TH1* histogram_Higgs)
{
const double xMin = 0.;
const double xMax = 200.;
double normalization_Z = getIntegral(histogram_Z, xMin, xMax);
double normalization_Higgs = getIntegral(histogram_Higgs, xMin, xMax);
assert(histogram_Z->GetNbinsX() == histogram_Higgs->GetNbinsX());
const double epsilon = 1.e-3;
double runningSum_Z = 0.;
double runningSum_Higgs = 0.;
int numBins = histogram_Z->GetNbinsX();
TGraph* graph = new TGraph(numBins);
for ( int iBin = numBins; iBin >= 1; --iBin ) {
assert(TMath::Abs(histogram_Z->GetBinCenter(iBin) - histogram_Higgs->GetBinCenter(iBin)) < epsilon);
double binCenter = histogram_Z->GetBinCenter(iBin);
if ( binCenter >= xMin && binCenter < xMax ) {
runningSum_Z += histogram_Z->GetBinContent(iBin);
runningSum_Higgs += histogram_Higgs->GetBinContent(iBin);
}
graph->SetPoint(iBin - 1, runningSum_Higgs/normalization_Higgs, 1. - runningSum_Z/normalization_Z);
}
return graph;
}
//********************
Double_t getPurity(Double_t DCA,TH1D*prim, TH1D * secondary){
Double_t int_prim = getIntegral(DCA,prim);
Double_t int_second = getIntegral(DCA,secondary);
if(int_prim && int_second) return (int_prim/(int_prim+int_second));
else return -1;
}
real IntegraleDeterministico::gauss()
{
resetIntegral();
real omega1 = ((real)128.)/225;
real omega23 = ((322+13*sqrt((real)70))/900);
real omega45 = ((322-13*sqrt((real)70))/900);
real xi23 = ( ((real)1) /3)*sqrt(5-2*sqrt( (real)(10./7) ));
real xi45 = ( ((real)1) /3)*sqrt(5+2*sqrt( (real)(10./7) ));
for (int i = 0; i < intervalli(); i++) {
real c = (x_i(i+1)+x_i(i))/2.;
real m = (x_i(i+1)-x_i(i))/2.;
// http://mathworld.wolfram.com/Legendre-GaussQuadrature.html
add( m*omega1*f_test(c) ); // root = 0
add( m*omega23*f_test(c - m*xi23) );
add( m*omega23*f_test(c + m*xi23) );
add( m*omega45*f_test(c - m*xi45) );
add( m*omega45*f_test(c + m*xi45) );
}
return getIntegral();
}
qreal getIntegral(const Triangle &triangle, const Polynom &polynom) {
QPointF points[3];
points[0] = triangle[0];
points[1] = triangle[1];
points[2] = triangle[2];
return getIntegral(points, polynom);
}
real IntegraleDeterministico::simpson()
{
resetIntegral();
for (int i = 0; i < intervalli()-1; i+=2) {
add( h()/3 * (f_test(x_i(i)) + 4*f_test(x_i(i+1)) + f_test(x_i(i+2)) ) );
}
return getIntegral();
}
real IntegraleDeterministico::trapezi()
{
resetIntegral();
for (int i = 0; i < intervalli(); i++) {
add( h()/2 * (f_test(x_i(i)) + f_test(x_i(i+1)) ) );
}
return getIntegral();
}
int main()
{
// freopen("14.input", "r", stdin);
int n;
point p1, p2, p3;
double area;
scanf("%d", &n);
while(n--)
{
//printf("Begin\n");
scanf("%lf %lf", &p1.x, &p1.y);
scanf("%lf %lf", &p2.x, &p2.y);
scanf("%lf %lf", &p3.x, &p3.y);
getParabola(p1, p2, p3);
getStraight(p2, p3);
area = getIntegral(p2.x, p3.x, 10000);
printf("%.2lf\n", area);
}
}
TGraph* makeIntGraph(const TH1* histogram)
{
const double xMin = 0.;
const double xMax = 200.;
double normalization = getIntegral(histogram, xMin, xMax);
double runningSum = 0.;
int numBins = histogram->GetNbinsX();
TGraph* graph = new TGraph(numBins);
for ( int iBin = numBins; iBin >= 1; --iBin ) {
double binCenter = histogram->GetBinCenter(iBin);
if ( binCenter >= xMin && binCenter < xMax ) {
runningSum += histogram->GetBinContent(iBin);
}
graph->SetPoint(iBin - 1, binCenter, runningSum/normalization);
}
return graph;
}
void GaborFilter::filter(const cv::Mat& grayFrame, std::vector<cv::Mat>& projections,
const cv::Mat& mask, int neighborhood, bool normalize) const {
cv::Mat dilatedMask;
if (!mask.empty() && neighborhood > 1) {
cv::dilate(mask, dilatedMask, cv::Mat(neighborhood, neighborhood, CV_8U, cv::Scalar(255)));
}
else {
dilatedMask = mask;
}
int dimensions = kernels.size();
projections.resize(dimensions);
for (int k = 0; k < dimensions; ++k) {
projections[k].create(grayFrame.size(), CV_32F);
projections[k].setTo(cv::Scalar(0));
for (int y = 0; y < grayFrame.rows; ++y) {
const uchar* maskPtr = (!dilatedMask.empty() ? dilatedMask.ptr(y) : NULL);
float* projPtr = projections[k].ptr<float> (y);
for (int x = 0; x < grayFrame.cols; ++x) {
float val = 0;
if (!maskPtr || maskPtr[x] > 0) {
for (int dy = -kernelRadius; dy <= kernelRadius; ++dy) {
int fy = y + dy;
if (fy >= 0 && fy < grayFrame.rows) {
const uchar* fPtr = grayFrame.ptr(fy);
const float* kPtr = kernels[k].ptr<float> (dy + kernelRadius);
for (int dx = -kernelRadius; dx <= kernelRadius; ++dx) {
int fx = x + dx;
if (fx >= 0 && fx < grayFrame.cols) {
val += fPtr[fx] * kPtr[dx + kernelRadius];
}
}
}
}
}
projPtr[x] = val;
}
}
if (neighborhood > 1) {
cv::Mat integral;
getIntegral(projections[k], integral);
for (int y = 0; y < grayFrame.rows; ++y) {
const uchar* maskPtr = (!mask.empty() ? mask.ptr(y) : NULL);
float* projPtr = projections[k].ptr<float> (y);
int y1 = std::max(y - (neighborhood - 1) / 2, 0);
int y2 = std::min(y + neighborhood / 2, grayFrame.rows - 1);
float* integralPtr1 = (y1 > 0 ? integral.ptr<float> (y1) : NULL);
float* integralPtr2 = integral.ptr<float> (y2);
for (int x = 0; x < grayFrame.cols; ++x) {
float val = 0;
if (!maskPtr || maskPtr[x] > 0) {
int x1 = std::max(x - (neighborhood - 1) / 2, 0);
int x2 = std::min(x + neighborhood / 2, grayFrame.cols - 1);
val += integralPtr2[x2];
if (integralPtr1) {
val -= integralPtr1[x2];
}
if (x1 > 0) {
val -= integralPtr2[x1 - 1];
}
if (integralPtr1 && x1 > 0) {
val += integralPtr1[x1 - 1];
}
val /= ((x2 - x1) + 1) * ((y2 - y1) + 1);
}
projPtr[x] = val;
}
}
}
if (normalize) {
cv::normalize(projections[k], projections[k], 0, 1, cv::NORM_MINMAX, -1, mask);
}
}
}
