Exemple #1
0
int main(int argc, char** argv)
{
 
 gROOT->Reset();
 gROOT->SetStyle("Plain");
 gStyle->SetPalette(1);
 gStyle->SetOptStat(1111);
 gStyle->SetOptFit(111);
 
 TF1 gaussian("gaussian","-exp(-0.1*x) + exp(-0.2 * x)",0,50);
 
 TH1F histo("histo","histo",1000,0,50);
 histo.FillRandom("gaussian",100000);
 
 TCanvas cc("cc","cc",400,400);
 
 histo.SetLineColor(kRed);
 histo.Draw();
 
 std::cerr << "===== Get Neyman intervals ====" << std::endl;

 std::vector<double> band = getSigmaBands_FeldmanCousins (histo) ;
 
 
 std::cerr << "=======================" << std::endl;
 std::cerr << " " << band.at(0) << " <<  " << band.at(1) << " << " << band.at(2) << " << " << band.at(3) << " << " << band.at(4) << std::endl;
 std::cerr << "=======================" << std::endl;
 
 TLine* lVertLeft95 = new TLine(band.at(0),0,band.at(0),1000);
 lVertLeft95->SetLineColor(kBlue);
 lVertLeft95->SetLineWidth(2);
 lVertLeft95->SetLineStyle(5);
 
 TLine* lVertLeft68 = new TLine(band.at(1),0,band.at(1),1000);
 lVertLeft68->SetLineColor(kMagenta);
 lVertLeft68->SetLineWidth(2);
 lVertLeft68->SetLineStyle(5);
 
 TLine* lVertMiddle = new TLine(band.at(2),0,band.at(2),1000);
 lVertMiddle->SetLineColor(kGreen);
 lVertMiddle->SetLineWidth(2);
 lVertMiddle->SetLineStyle(5);
 
 TLine* lVertRight68 = new TLine(band.at(3),0,band.at(3),1000);
 lVertRight68->SetLineColor(kMagenta);
 lVertRight68->SetLineWidth(2);
 lVertRight68->SetLineStyle(5);

 TLine* lVertRight95 = new TLine(band.at(4),0,band.at(4),1000);
 lVertRight95->SetLineColor(kBlue);
 lVertRight95->SetLineWidth(2);
 lVertRight95->SetLineStyle(5);
 
 
 lVertLeft95->Draw();
 lVertLeft68->Draw();
 lVertMiddle->Draw();
 lVertRight68->Draw();
 lVertRight95->Draw();
 
 cc.SaveAs("exampleBand.png");
 
 
 
  
  return 0;
}
Exemple #2
0
 /**
  * Generate a gaussian random variable with zero mean and unit
  * variance.
  */
 inline double normal(const double mean = double(0), 
                      const double stdev = double(1)) {
   return gaussian(mean, stdev);
 } // end of normal
Exemple #3
0
//! Get the modified descriptor. See Agrawal ECCV 08
//! Modified descriptor contributed by Pablo Fernandez
void Surf::getDescriptor(bool bUpright)
{
  int y, x, sample_x, sample_y, count=0;
  int i = 0, ix = 0, j = 0, jx = 0, xs = 0, ys = 0;
  float scale, *desc, dx, dy, mdx, mdy, co, si;
  float gauss_s1 = 0.f, gauss_s2 = 0.f;
  float rx = 0.f, ry = 0.f, rrx = 0.f, rry = 0.f, len = 0.f;
  float cx = -0.5f, cy = 0.f; //Subregion centers for the 4x4 gaussian weighting

  Ipoint *ipt = &ipts[index];
  scale = ipt->scale;
  x = fRound(ipt->x);
  y = fRound(ipt->y);  
  desc = ipt->descriptor;

  if (bUpright)
  {
    co = 1;
    si = 0;
  }
  else
  {
    co = cos(ipt->orientation);
    si = sin(ipt->orientation);
  }

  i = -8;

  //Calculate descriptor for this interest point
  while(i < 12)
  {
    j = -8;
    i = i-4;

    cx += 1.f;
    cy = -0.5f;

    while(j < 12) 
    {
      dx=dy=mdx=mdy=0.f;
      cy += 1.f;

      j = j - 4;

      ix = i + 5;
      jx = j + 5;

      xs = fRound(x + ( -jx*scale*si + ix*scale*co));
      ys = fRound(y + ( jx*scale*co + ix*scale*si));

      for (int k = i; k < i + 9; ++k) 
      {
        for (int l = j; l < j + 9; ++l) 
        {
          //Get coords of sample point on the rotated axis
          sample_x = fRound(x + (-l*scale*si + k*scale*co));
          sample_y = fRound(y + ( l*scale*co + k*scale*si));

          //Get the gaussian weighted x and y responses
          gauss_s1 = gaussian(xs-sample_x,ys-sample_y,2.5f*scale);
          rx = haarX(sample_y, sample_x, 2*fRound(scale));
          ry = haarY(sample_y, sample_x, 2*fRound(scale));

          //Get the gaussian weighted x and y responses on rotated axis
          rrx = gauss_s1*(-rx*si + ry*co);
          rry = gauss_s1*(rx*co + ry*si);

          dx += rrx;
          dy += rry;
          mdx += fabs(rrx);
          mdy += fabs(rry);

        }
      }

      //Add the values to the descriptor vector
      gauss_s2 = gaussian(cx-2.0f,cy-2.0f,1.5f);

      desc[count++] = dx*gauss_s2;
      desc[count++] = dy*gauss_s2;
      desc[count++] = mdx*gauss_s2;
      desc[count++] = mdy*gauss_s2;

      len += (dx*dx + dy*dy + mdx*mdx + mdy*mdy) * gauss_s2*gauss_s2;

      j += 9;
    }
    i += 9;
  }

  //Convert to Unit Vector
  len = sqrt(len);
  for(int i = 0; i < 64; ++i)
    desc[i] /= len;

}
/**
 *
 * Function to compute the optical flow using multiple scales
 *
 **/
void Dual_TVL1_optic_flow_multiscale(
		float *I0,           // source image
		float *I1,           // target image
		float *u1,           // x component of the optical flow
		float *u2,           // y component of the optical flow
		const int   nxx,     // image width
		const int   nyy,     // image height
		const float tau,     // time step
		const float lambda,  // weight parameter for the data term
		const float theta,   // weight parameter for (u - v)²
		const int   nscales, // number of scales
		const float zfactor, // factor for building the image piramid
		const int   warps,   // number of warpings per scale
		const float epsilon, // tolerance for numerical convergence
		const bool  verbose  // enable/disable the verbose mode
)
{
	int size = nxx * nyy;

	// allocate memory for the pyramid structure
	float **I0s = xmalloc(nscales * sizeof(float*));
	float **I1s = xmalloc(nscales * sizeof(float*));
	float **u1s = xmalloc(nscales * sizeof(float*));
	float **u2s = xmalloc(nscales * sizeof(float*));
	int    *nx  = xmalloc(nscales * sizeof(int));
	int    *ny  = xmalloc(nscales * sizeof(int));

	I0s[0] = xmalloc(size*sizeof(float));
	I1s[0] = xmalloc(size*sizeof(float));

	u1s[0] = u1;
	u2s[0] = u2;
	nx [0] = nxx;
	ny [0] = nyy;

	// normalize the images between 0 and 255
	image_normalization(I0, I1, I0s[0], I1s[0], size);

	// pre-smooth the original images
	gaussian(I0s[0], nx[0], ny[0], PRESMOOTHING_SIGMA);
	gaussian(I1s[0], nx[0], ny[0], PRESMOOTHING_SIGMA);

	// create the scales
	for (int s = 1; s < nscales; s++)
	{
		zoom_size(nx[s-1], ny[s-1], &nx[s], &ny[s], zfactor);
		const int sizes = nx[s] * ny[s];

		// allocate memory
		I0s[s] = xmalloc(sizes*sizeof(float));
		I1s[s] = xmalloc(sizes*sizeof(float));
		u1s[s] = xmalloc(sizes*sizeof(float));
		u2s[s] = xmalloc(sizes*sizeof(float));

		// zoom in the images to create the pyramidal structure
		zoom_out(I0s[s-1], I0s[s], nx[s-1], ny[s-1], zfactor);
		zoom_out(I1s[s-1], I1s[s], nx[s-1], ny[s-1], zfactor);
	}

	// initialize the flow at the coarsest scale
	for (int i = 0; i < nx[nscales-1] * ny[nscales-1]; i++)
		u1s[nscales-1][i] = u2s[nscales-1][i] = 0.0;

	// pyramidal structure for computing the optical flow
	for (int s = nscales-1; s >= 0; s--)
	{
		if (verbose)
			fprintf(stderr, "Scale %d: %dx%d\n", s, nx[s], ny[s]);

		// compute the optical flow at the current scale
		Dual_TVL1_optic_flow(
				I0s[s], I1s[s], u1s[s], u2s[s], nx[s], ny[s],
				tau, lambda, theta, warps, epsilon, verbose
		);

		// if this was the last scale, finish now
		if (!s) break;

		// otherwise, upsample the optical flow

		// zoom the optical flow for the next finer scale
		zoom_in(u1s[s], u1s[s-1], nx[s], ny[s], nx[s-1], ny[s-1]);
		zoom_in(u2s[s], u2s[s-1], nx[s], ny[s], nx[s-1], ny[s-1]);

		// scale the optical flow with the appropriate zoom factor
		for (int i = 0; i < nx[s-1] * ny[s-1]; i++)
		{
			u1s[s-1][i] *= (float) 1.0 / zfactor;
			u2s[s-1][i] *= (float) 1.0 / zfactor;
		}
	}

	// delete allocated memory
	for (int i = 1; i < nscales; i++)
	{
		free(I0s[i]);
		free(I1s[i]);
		free(u1s[i]);
		free(u2s[i]);
	}
	free(I0s[0]);
	free(I1s[0]);

	free(I0s);
	free(I1s);
	free(u1s);
	free(u2s);
	free(nx);
	free(ny);
}
edge_image_type IonDetector::canny_edge( const image_type& img ) {
	image_type::extents_type three( 3, 3 );
	Kernel gaussian( image_type( three, boost::assign::list_of
		( 1./16 )( 2./16 )( 1./16 )
		( 2./16 )( 4./16 )( 2./16 )
		( 1./16 )( 2./16 )( 1./16 ) ) );
	Kernel sobelx( image_type( three, boost::assign::list_of
		(1)(0)(-1)(2)(0)(-2)(1)(0)(-1) ) );
	Kernel sobely( image_type( three, boost::assign::list_of
		(1)(2)(1)(0)(0)(0)(-1)(-2)(-1) ) );

	image_type img_gauss( img.extents ), img_sobelx( img.extents ),
		img_sobely( img.extents );

	//gaussian.apply_kernel( img, img_gauss );
	sobelx.apply_kernel( img, img_sobelx );
	sobely.apply_kernel( img, img_sobely );

	save_file( "orig.fits", img );
	//save_file( "gauss.fits", img_gauss );
	//save_file( "sobelx.fits", img_sobelx );
	//save_file( "sobely.fits", img_sobely );

	image_type img_sobel( img_sobelx.extents );
	edge_image_type edges( img_sobelx.extents );

	image_type::element mean = 0, std_dev = 0;
	for( image_type::index i = 2; i < img_sobelx.extents.first-2; ++i ) 
	for( image_type::index j = 2; j < img_sobelx.extents.second-2; ++j ) {
		image_type::element val = img_sobelx( i, j )*img_sobelx( i, j ) +
			img_sobely( i, j )*img_sobely( i, j );
		img_sobel( i, j ) = val;
		mean += val;
	}

	save_file( "sobel.fits", img_sobel );
	
	mean /= img_sobel.num_elements();	
	for( image_type::index i = 2; i<img_sobelx.extents.first-2; ++i ) 
	for( image_type::index j = 2; j<img_sobelx.extents.second-2; ++j ) {
		std_dev += ( img_sobel( i, j ) - mean )*
			( img_sobel( i, j ) - mean );
	}
			
	std_dev = sqrt(std_dev / img_sobel.num_elements());
	image_type::element thresh = mean + canny_threshold * std_dev;
	image_type::element continue_thresh = mean + 
		canny_continue_threshold * std_dev;

	// First mark off edges with a high threshold
	for( image_type::index i = 2; i<img_sobelx.extents.first-2; ++i ) 
	for( image_type::index j = 2; j<img_sobelx.extents.second-2; ++j ) {
		edge_image_type::position pos( i, j );
		if( edges( pos ) ) continue;
		if(	canny_check( img_sobel, img_sobelx, img_sobely, 
				pos, thresh ) ) {
			std::stack< image_type::position > checks;
			checks.push( pos );

			while( !checks.empty() ) {
				pos = checks.top();
				checks.pop();

				if( edges( pos ) ) continue;
				if( !canny_check( img_sobel, img_sobelx, img_sobely, 
						pos, continue_thresh ) ) 
					continue;

				edges( pos ) = 1.0f;
				pos.first++;	checks.push( pos );
				pos.second++;	checks.push( pos );
				pos.second-=2;	checks.push( pos );
				pos.first--;	checks.push( pos );
				pos.second+=2;	checks.push( pos );
				pos.first--;	checks.push( pos );
				pos.second--;	checks.push( pos );
				pos.second--;	checks.push( pos );
			}
		}
	}

		
	save_file( "edges.fits", edges );
	return edges;
}
  void ComputeMSURFDescriptor(
    const ImageT & Lx ,
    const ImageT & Ly ,
    const int id_octave ,
    const SIOPointFeature & ipt ,
    Descriptor< Real , 64 > & desc )
  {

    Real dx = 0, dy = 0, mdx = 0, mdy = 0, gauss_s1 = 0, gauss_s2 = 0;
    Real rx = 0, ry = 0, rrx = 0, rry = 0, xf = 0, yf = 0, ys = 0, xs = 0;
    Real sample_x = 0, sample_y = 0, co = 0, si = 0, angle = 0;
    Real ratio = 0;
    int x1 = 0, y1 = 0, x2 = 0, y2 = 0, sample_step = 0, pattern_size = 0;
    int kx = 0, ky = 0, i = 0, j = 0, dcount = 0;
    int scale = 0, dsize = 0, level = 0;

    // Subregion centers for the 4x4 gaussian weighting
    Real cx = - static_cast<Real>( 0.5 ) , cy = static_cast<Real>( 0.5 ) ;

    // Set the descriptor size and the sample and pattern sizes
    dsize = 64;
    sample_step = 5;
    pattern_size = 12;

    // Get the information from the keypoint
    ratio = static_cast<Real>( 1 << id_octave );
    scale = MathTrait<float>::round( ipt.scale() / ratio );
    angle = ipt.orientation() ;
    yf = ipt.y() / ratio;
    xf = ipt.x() / ratio;
    co = MathTrait<Real>::cos( angle );
    si = MathTrait<Real>::sin( angle );

    i = -8;

    // Calculate descriptor for this interest point
    // Area of size 24 s x 24 s
    while ( i < pattern_size )
    {
      j = -8;
      i = i - 4;

      cx += 1.0;
      cy = -0.5;

      while ( j < pattern_size )
      {
        dx = dy = mdx = mdy = 0.0;
        cy += 1.0;
        j = j - 4;

        ky = i + sample_step;
        kx = j + sample_step;

        xs = xf + ( -kx * scale * si + ky * scale * co );
        ys = yf + ( kx * scale * co + ky * scale * si );

        for ( int k = i; k < i + 9; ++k )
        {
          for ( int l = j; l < j + 9; ++l )
          {
            // Get coords of sample point on the rotated axis
            sample_y = yf + ( l * scale * co + k * scale * si );
            sample_x = xf + ( -l * scale * si + k * scale * co );

            // Get the gaussian weighted x and y responses
            gauss_s1 = gaussian( xs - sample_x, ys - sample_y, static_cast<Real>( 2.5 ) * static_cast<Real>( scale ) );

            rx = SampleLinear( Lx, sample_y, sample_x );
            ry = SampleLinear( Ly, sample_y, sample_x );

            // Get the x and y derivatives on the rotated axis
            rry = gauss_s1 * ( rx * co + ry * si );
            rrx = gauss_s1 * ( -rx * si + ry * co );

            // Sum the derivatives to the cumulative descriptor
            dx += rrx;
            dy += rry;
            mdx += MathTrait<Real>::abs( rrx );
            mdy += MathTrait<Real>::abs( rry );
          }
        }

        // Add the values to the descriptor vector
        gauss_s2 = gaussian( cx - static_cast<Real>( 2.0 ) , cy - static_cast<Real>( 2.0 ) , static_cast<Real>( 1.5 ) ) ;
        desc[dcount++] = dx * gauss_s2;
        desc[dcount++] = dy * gauss_s2;
        desc[dcount++] = mdx * gauss_s2;
        desc[dcount++] = mdy * gauss_s2;

        j += 9;
      }

      i += 9;
    }

    // convert to unit vector (L2 norm)
    typedef Eigen::Matrix<Real, Eigen::Dynamic, 1> VecReal;
    Eigen::Map< VecReal > dataMap( &desc[0], 64);
    dataMap.normalize();
    //std::cout << dataMap.transpose() << std::endl << std::endl;
  }
double* Network::activate(double* inputs)
{
	
	int totalInputs = inputCount + biasCount;
	
		//set bias
	for(int i=0; i < biasCount; i++)
		registers[i] = 1.0;

	//set inputs
	for(int i=0; i < inputCount; i++)
		registers[i+biasCount] = inputs[i];

	for(int i=0; i < nodeCount; i++)
	{
		//activate in order
		int tgtNeuronIx = nodeOrder[i];

		//skip inputs and bias
		if(tgtNeuronIx < totalInputs)
			continue;


		//Hello. Are you there?


		//Ix

		int* regIxArray = registerArrays[tgtNeuronIx];
		int* weightIxArray = weightArrays[tgtNeuronIx];

		int nCount = nodeIncoming[tgtNeuronIx];
		int aType = activationTypes[tgtNeuronIx];

		double nodeSum = 0;

		for(int r=0; r < nCount; r++)
		{
			nodeSum += registers[regIxArray[r]]*weights[weightIxArray[r]];
		}

		switch(aType)
		{
			case ActivationInt::BipolarSigmoid:
				registers[tgtNeuronIx] = bipolarSigmoid(nodeSum);
				break;

			case ActivationInt::Gaussian:
				registers[tgtNeuronIx] = gaussian(nodeSum);
				break;
			case ActivationInt::Linear:
				registers[tgtNeuronIx] = linear(nodeSum);
				break;
			case ActivationInt::Sine:
				registers[tgtNeuronIx] = sine(nodeSum);
				break;
			case ActivationInt::StepFunction:
				registers[tgtNeuronIx] = stepFunction(nodeSum);
				break;
		}

		printf("tgtIx %d - calc: %f \n", tgtNeuronIx, registers[tgtNeuronIx]);

		//register done, move on!
	}
	
	//activate 
	double* fullOutputs = new double[outputCount];

	//copy to double array
	memcpy (fullOutputs,  &registers[totalInputs], outputCount);

	//send back registers starting at outputs!
	return fullOutputs;
}
Exemple #8
0
void BfmWrapper::SpectralRange(bfm_qdp<Float>  &bfm)
{
  int Ls = bfm.Ls;
  multi1d<T4> gaus(Ls);
  for(int s=0;s<Ls;s++)
    gaussian(gaus[s]);


  Fermion_t tmp1,tmp2;
  Fermion_t b;
  Fermion_t Ab;
  double mu;
  tmp1   = bfm.allocFermion();
  tmp2   = bfm.allocFermion();
  b      = bfm.allocFermion();
  Ab     = bfm.allocFermion();

  bfm.importFermion(gaus,b,0);
  
  int dagyes= 1;
  int dagno = 0;
  int donrm = 1;
  double abnorm;
  double absq;
  double n;
  ///////////////////////////////////////
  // Get the highest evalue of MdagM
  ///////////////////////////////////////
#pragma omp parallel for  
for(int i=0;i<bfm.nthread;i++) {
  int me = bfm.thread_barrier();

  for(int k=0;k<100;k++){

    n = bfm.norm(b);

    absq = bfm.Mprec(b,tmp2,tmp1,dagno,donrm);
           bfm.Mprec(tmp2,Ab,tmp1,dagyes); //MdagM
    
    mu = absq/n;
    if(bfm.isBoss() && (!me) ) { 
      printf("PowerMethod %d mu=%le absq=%le n=%le \n",k,mu,absq,n);
    }

    abnorm = sqrt(absq);

    // b = Ab / |Ab|
    bfm.axpby(b,Ab,Ab,0.0,1.0/abnorm);
  }
 }

 /////////////////////////////////////////
 // Get the lowest eigenvalue of mdagm
 // Apply power method to [lambda_max - MdagM]
 /////////////////////////////////////////
 double lambda_max = mu;

 bfm.importFermion(gaus,b,0);

#pragma omp parallel for  
for(int i=0;i<bfm.nthread;i++) {
  int me = bfm.thread_barrier();

  for(int k=0;k<100;k++){

    n = bfm.norm(b);

    absq = bfm.Mprec(b,tmp2,tmp1,dagno,donrm);
    bfm.Mprec(tmp2,Ab,tmp1,dagyes); 
    bfm.axpby(Ab,Ab,b,-1,lambda_max);

    absq = lambda_max * n - absq;

    mu = absq/n;

    if(bfm.isBoss() && (!me) ) { 
      printf("PowerMethod for low EV %d mu=%le absq=%le n=%le \n",k,mu,absq,n);
      printf("PowerMethod  %d lambda_min  =%le\n",k,lambda_max - mu);
    }

    abnorm = sqrt(absq);

    // b = Ab / |Ab|
    bfm.axpby(b,Ab,Ab,0.0,1.0/abnorm);

  }
}

  bfm.freeFermion(tmp1);
  bfm.freeFermion(tmp2);
  bfm.freeFermion(b);
  bfm.freeFermion(Ab);


}
Exemple #9
0
float gabor(V2d v,V2d d,float size,float freq) {
  return gaussian(v.mag()/size)*sin(v.dot(d)*freq);
}