C++ canvas函数代码示例

/*!
  Nothing else than: canvas()->palette().brush(
        QPalette::Normal, QPalette::Window);

  \return Background brush of the plotting area.
  \sa setCanvasBackground()
*/
QBrush QwtPlot::canvasBackground() const
{
    return canvas()->palette().brush(
               QPalette::Normal, QPalette::Window );
}

ribi::QtToolTestApproximatorXyzMainDialog::QtToolTestApproximatorXyzMainDialog(QWidget *parent) noexcept :
  QtHideAndShowDialog(parent),
  ui(new Ui::QtToolTestApproximatorXyzMainDialog),
  m_approximator(),
  m_data(CreateData())
{
  #ifndef NDEBUG
  Test();
  #endif
  ui->setupUi(this);

  //Set up the plots and curves
  GetPlot(0)->setTitle("Approximator, for z = 0.0");
  GetPlot(1)->setTitle("Approximator, for z = 0.5");
  GetPlot(2)->setTitle("Approximator, for z = 1.0");
  for (auto i=0; i!=m_n_curves; ++i)
  {
    const auto plot = GetPlot(i);
    plot->setAxisTitle(QwtPlot::xBottom,"X");
    plot->setAxisTitle(QwtPlot::yLeft,"Y");
    #ifdef _WIN32
    plot->setCanvasBackground(QBrush(QColor(255,255,255)));
    #else
    plot->setCanvasBackground(QColor(255,255,255));
    #endif

    const auto curve_values = GetCurveValues(i);
    assert(curve_values);
    curve_values->setTitle("Points");
    curve_values->attach(plot.get());
    curve_values->setStyle(QwtPlotCurve::Dots);
    curve_values->setPen(QPen(QColor(255,0,0),5));

    const auto curve_approximation = GetCurveApproximation(i);
    assert(curve_approximation);
    curve_approximation->setTitle("Approximation");
    curve_approximation->attach(plot.get());
    curve_approximation->setStyle(QwtPlotCurve::Dots);
    curve_approximation->setPen(QPen(QColor(0,0,255),3));

    //Add grid
    {
      QwtPlotGrid * const grid = new QwtPlotGrid;
      grid->setPen(QPen(QColor(128,128,128)));
      grid->attach(plot.get());
    }
    //Add zoomer
    {
      new QwtPlotZoomer(plot->canvas());
    }
    //Add legend
    {
      QwtLegend * const legend = new QwtLegend;
      legend->setFrameStyle(QFrame::Box|QFrame::Sunken);
      plot->insertLegend(legend, QwtPlot::RightLegend);
    }

    plot->setAxisScale(
      QwtPlot::xBottom,
      static_cast<double>(ui->box_int_x->minimum()),
      static_cast<double>(ui->box_int_x->maximum())
    );
    plot->setAxisScale(
      QwtPlot::yLeft,
      static_cast<double>(ui->box_double_y->minimum()),
      static_cast<double>(ui->box_double_y->maximum())
    );

    //Add to dialog
    assert(ui->verticalLayout->layout());
    ui->verticalLayout->layout()->addWidget(plot.get());
  }




  //Add some nice testing values
  ui->box_int_x->setValue(ui->box_int_x->minimum() / 2);
  ui->box_double_y->setValue(ui->box_double_y->maximum() / 2.0);
  on_button_clicked();

  ui->box_int_x->setValue(ui->box_int_x->minimum() / 4);
  ui->box_double_y->setValue(ui->box_double_y->minimum() / 2.0);
  on_button_clicked();

  ui->box_int_x->setValue(ui->box_int_x->maximum() / 4);
  ui->box_double_y->setValue(ui->box_double_y->maximum() / 2.0);
  on_button_clicked();

  ui->box_int_x->setValue(ui->box_int_x->maximum() / 2);
  ui->box_double_y->setValue(ui->box_double_y->minimum() / 2.0);
  on_button_clicked();

  ui->box_int_x->setValue(0);
  ui->box_double_y->setValue(0.0);
}

int App::start(const std::vector<std::string> &args)
{
	clan::DisplayWindowDescription description;
	description.set_title("Thread Example");
	description.set_size(clan::Size(1024, 768), true);

	clan::DisplayWindow window(description);
	clan::InputDevice keyboard = window.get_ic().get_keyboard();
	clan::Canvas canvas(window);
    clan::SlotContainer cc;

	cc.connect(window.get_ic().get_keyboard().sig_key_up(), clan::bind_member(this, &App::on_input_up));

	cc.connect(window.sig_window_close(), clan::bind_member(this, &App::window_close));

	// Load the font
	clan::Font font(canvas, "tahoma", 32);

	// Create the initial textures
	texture_buffers[0] = clan::Texture2D(canvas, texture_size, texture_size);
	texture_buffers[1] = clan::Texture2D(canvas, texture_size, texture_size);

	// Create the initial pixelbuffers
	pixel_buffers[0] = clan::PixelBuffer(texture_size, texture_size, clan::tf_rgba8);
	pixel_buffers[1] = clan::PixelBuffer(texture_size, texture_size, clan::tf_rgba8);

	// Initially clear the textures, so they are filled with a "Calculating..." message
	clan::FrameBuffer framebuffer(canvas);
	framebuffer.attach_color(0, texture_buffers[0]);
	clan::Canvas canvas_fb( canvas, framebuffer );
	canvas_fb.clear();
	font.draw_text(canvas_fb, 32, 96, "Calculating...");
	canvas_fb.flush();
	framebuffer.attach_color(0, texture_buffers[1]);
	canvas_fb = clan::Canvas( canvas, framebuffer );
	canvas_fb.clear();
	font.draw_text(canvas_fb, 32, 96, "Calculating...");
	canvas_fb.flush();

	// Setup the initial texture double buffering variables

	texture_buffers_offset = 0;
	pixel_buffers_offset = 0;
	worker_thread_complete = false;
	
	texture_write = &texture_buffers[0];
	texture_completed = &texture_buffers[1];
	pixelbuffer_write = &pixel_buffers[0];
	pixelbuffer_completed = &pixel_buffers[1];

	dest_pixels = NULL;
	quit = false;
	crashed_flag = false;

	clan::MutexSection worker_thread_mutex_section(&worker_thread_mutex, false);

	// We require a try block, so the worker thread exits correctly
	clan::Thread thread;
	try
	{
		thread.start(this, &App::worker_thread);

		// Main loop
		FramerateCounter framerate_counter;
		FramerateCounter worker_thread_framerate_counter;
		clan::ubyte64 last_time = clan::System::get_time();
		clan::ubyte64 last_mandelbrot_time = clan::System::get_time();

		float angle = 0.0f;
		bool worker_thread_started = false;
		bool texture_write_active = false;

		while (!quit)
		{
			framerate_counter.frame_shown();

			// Calculate timings
			clan::ubyte64 current_time = clan::System::get_time();
			float time_delta_ms = (float) (current_time - last_time);
			last_time = current_time;

			angle += time_delta_ms / 50.0f;
			while(angle > 360.0f)
				angle-=360.0f;

			canvas.clear();
			
			// If the pixel buffer was uploaded on the last frame, double buffer it
			if (texture_write_active)
			{
				texture_write_active = false;
				if (texture_buffers_offset == 0)
				{
					texture_buffers_offset = 1;
					texture_write = &texture_buffers[1];
					texture_completed = &texture_buffers[0];
				}
				else
				{
					texture_buffers_offset = 0;
//.........这里部分代码省略.........

ProgressWindow::ProgressWindow(ContainerWindow &parent)
  :background_color(COLOR_WHITE),
   background_brush(background_color),
   position(0)
{
  PixelRect rc = parent.GetClientRect();
  WindowStyle style;
  style.Hide();
  Create(parent, rc, style);

  const unsigned width = rc.right - rc.left, height = rc.bottom - rc.top;

  // Load progress bar background
  bitmap_progress_border.Load(IDB_PROGRESSBORDER);

  // Determine text height
#ifndef USE_GDI
  font.Load(FontDescription(Layout::FontScale(10)));
  text_height = font.GetHeight();
#else
  VirtualCanvas canvas({1, 1});
  text_height = canvas.GetFontHeight();
#endif

  // Make progress bar height proportional to window height
  const unsigned progress_height = height / 20;
  const unsigned progress_horizontal_border = progress_height / 2;
  progress_border_height = progress_height * 2;

  // Initialize message text field
  PixelRect message_rc = rc;
  message_rc.bottom -= progress_border_height + height / 48;
  message_rc.top = message_rc.bottom - text_height;
  TextWindowStyle message_style;
  message_style.center();
  message.Create(*this, nullptr, message_rc, message_style);

#ifndef USE_GDI
  message.SetFont(font);
#endif

  // Initialize progress bar
  PixelRect pb_rc;
  pb_rc.left = progress_horizontal_border;
  pb_rc.right = pb_rc.left + width - progress_height;
  pb_rc.top = height - progress_border_height + progress_horizontal_border;
  pb_rc.bottom = pb_rc.top + progress_height;
  ProgressBarStyle pb_style;
  progress_bar.Create(*this, pb_rc, pb_style);

#ifdef USE_GDI
  message.InstallWndProc(); // needed for OnChildColor()
#endif

  // Set progress bar step size and range
  SetRange(0, 1000);
  SetStep(50);

  // Show dialog
  ShowOnTop();
}

void ColDiagramView::dropEvent(QDropEvent * e)
{
    BrowserNode * bn;
    QPoint p = viewportToContents(e->pos());

    if ((bn = UmlDrag::decode(e, UmlClassInstance)) != 0) {
        history_save();

        CodClassInstCanvas * i =
            new CodClassInstCanvas((BrowserClassInstance *) bn,
                                   the_canvas(), p.x(), p.y(), 0);

        history_protected = TRUE;
        i->show();
        i->upper();
        canvas()->update();
        history_protected = FALSE;
        window()->package_modified();
    }
    else if ((bn = UmlDrag::decode(e, UmlClass)) != 0) {
        history_save();

        CodClassInstCanvas * cli =
            new CodClassInstCanvas(bn, the_canvas(), p.x(), p.y(), 0);

        history_protected = TRUE;
        cli->show();
        cli->upper();
        canvas()->update();
        history_protected = FALSE;
        window()->package_modified();
    }
    else if ((bn = UmlDrag::decode(e, UmlPackage)) != 0) {
        history_save();

        PackageCanvas * pk =
            new PackageCanvas(bn, the_canvas(), p.x(), p.y(), 0);

        history_protected = TRUE;
        pk->show();
        pk->upper();
        canvas()->update();
        window()->package_modified();
    }
    else if (((bn = UmlDrag::decode(e, UmlClassDiagram)) != 0) ||
             ((bn = UmlDrag::decode(e, UmlUseCaseDiagram)) != 0) ||
             ((bn = UmlDrag::decode(e, UmlSeqDiagram)) != 0) ||
             ((bn = UmlDrag::decode(e, UmlColDiagram)) != 0) ||
             ((bn = UmlDrag::decode(e, UmlObjectDiagram)) != 0) ||
             ((bn = UmlDrag::decode(e, UmlComponentDiagram)) != 0) ||
             ((bn = UmlDrag::decode(e, UmlDeploymentDiagram)) != 0) ||
             ((bn = UmlDrag::decode(e, UmlStateDiagram, TRUE)) != 0) ||
             ((bn = UmlDrag::decode(e, UmlActivityDiagram, TRUE)) != 0)) {
        history_save();

        IconCanvas * ic = new IconCanvas(bn, the_canvas(), p.x(), p.y(), 0);

        history_protected = TRUE;
        ic->show();
        ic->upper();
        canvas()->update();
        history_protected = FALSE;
        window()->package_modified();
    }
}

void ScrollZoomer::updateScrollBars() {
  if (!canvas()) return;

  const int xAxis = QwtPlotZoomer::xAxis();
  const int yAxis = QwtPlotZoomer::yAxis();

  int xScrollBarAxis = xAxis;
  if (hScrollBarPosition() == OppositeToScale)
    xScrollBarAxis = oppositeAxis(xScrollBarAxis);

  int yScrollBarAxis = yAxis;
  if (vScrollBarPosition() == OppositeToScale)
    yScrollBarAxis = oppositeAxis(yScrollBarAxis);

  QwtPlotLayout *layout = plot()->plotLayout();

  bool showHScrollBar = needScrollBar(Qt::Horizontal);
  if (showHScrollBar)
    {
      ScrollBar *sb = scrollBar(Qt::Horizontal);

      sb->setPalette(plot()->palette());

      const QwtScaleDiv *sd = &plot()->axisScaleDiv(xAxis);
      sb->setInverted(sd->lowerBound() > sd->upperBound());

      sb->setBase(zoomBase().left(), zoomBase().right());
      sb->moveSlider(zoomRect().left(), zoomRect().right());

      if (!sb->isVisibleTo(canvas()))
        {
          sb->show();
          layout->setCanvasMargin(layout->canvasMargin(xScrollBarAxis)
              + sb->extent(), xScrollBarAxis);
        }
    }
  else
    {
      if (horizontalScrollBar())
        {
          horizontalScrollBar()->hide();
          layout->setCanvasMargin(layout->canvasMargin(xScrollBarAxis)
              - horizontalScrollBar()->extent(), xScrollBarAxis);
        }
    }

  bool showVScrollBar = needScrollBar(Qt::Vertical);
  if (showVScrollBar)
    {
      ScrollBar *sb = scrollBar(Qt::Vertical);

      sb->setPalette(plot()->palette());

      const QwtScaleDiv *sd = &plot()->axisScaleDiv(yAxis);
      sb->setInverted(sd->lowerBound() < sd->upperBound());

      sb->setBase(zoomBase().top(), zoomBase().bottom());
      sb->moveSlider(zoomRect().top(), zoomRect().bottom());

      if (!sb->isVisibleTo(canvas()))
        {
          sb->show();
          layout->setCanvasMargin(layout->canvasMargin(yScrollBarAxis)
              + sb->extent(), yScrollBarAxis);
        }
    }
  else
    {
      if (verticalScrollBar())
        {
          verticalScrollBar()->hide();
          layout->setCanvasMargin(layout->canvasMargin(yScrollBarAxis)
              - verticalScrollBar()->extent(), yScrollBarAxis);
        }
    }

  if (showHScrollBar && showVScrollBar)
    {
      if (d_cornerWidget == NULL)
        {
          d_cornerWidget = new QWidget(canvas());
#if QT_VERSION >= 0x040100
          d_cornerWidget->setAutoFillBackground(true);
#endif
          d_cornerWidget->setPalette(plot()->palette());
        }
      d_cornerWidget->show();
    }
  else
    {
      if (d_cornerWidget)
        d_cornerWidget->hide();
    }

  layoutScrollBars(((QwtPlotCanvas *) canvas())->contentsRect());
  plot()->updateLayout();
}

//.........这里部分代码省略.........
    nuance_var=new TString("sqrt((p_neutrino[0]-p_lepton[0][0]+p_targ[0])**2+(p_neutrino[1]-p_lepton[0][1]+p_targ[1])**2+(p_neutrino[2]-p_lepton[0][2]+p_targ[2])**2)/1.0e3");
    nuance_cut=new TCut("cc && bound && channel==1 && n_leptons==1");
    label=new TString(";p_{f} (GeV/c);(<events>/POT/target) / (GeV/c)");

    x_leg=0.15;
    N_bins=150;
    lower=0.2;
    upper=1.3;
    break;
  case 6:
    tree_var=new TString("k[0]");
    nuance_var=new TString("p_neutrino[3]/1.0e3");
    nuance_cut=new TCut("cc && bound && channel==1 && n_leptons==1");
    label=new TString(";E_{#nu} (GeV);(<events>/POT/target) / GeV");

    x_leg=0.15;
    N_bins=150;
    lower=0.0;
    upper=2.0;
    break;
  case 7:
    tree_var=new TString("k[0]");
    nuance_var=new TString("p_neutrino[3]/1.0e3");
    nuance_cut=new TCut("cc && bound && channel==1 && n_leptons==1");
    label=new TString(";E_{#nu} (GeV);(<events>/POT/target) / GeV");

    x_leg=0.15;
    N_bins=150;
    lower=0.0;
    upper=5.0;
    break;
  }

  TCanvas canvas("canvas","",700,1000);
  canvas.Divide(1,2);
  canvas.cd(1);
  TH1D nh("nh",*label,N_bins,lower,upper);
  nh.Sumw2();
  nh.SetStats(kFALSE);

  Int_t NFiles=40;
  for (Int_t iFile=0;iFile<NFiles;iFile++) {
    TString file;
    if (!antinu) file="../../nuance_from_fnal/oxygen_dipole_mbflux_e"+linlog+Form("_81/nuance%d.root",iFile+1);
    if ( antinu) file=Form("../../nuance_from_fnal/oxygen_dipole_mbflux_antinu_elog_81/nuance%d.root",iFile+1);
    TFile f(file);
    gROOT->cd();
    TTree *ntree=(TTree*)f.Get("h3");
    ntree->Draw(*nuance_var+">>+nh",*nuance_cut,"goff");
    f.Close();
  }
  if (linlog=="log") {
    if (!antinu) nh.Scale(2.29697e-07*8*1.0e-36/nh.Integral("width"));
    if ( antinu) nh.Scale(7.47831e-08*8*1.0e-36/nh.Integral("width"));
  }
  else nh.Scale(1.0/nh.Integral("width"));
  nh.Scale(mb_factor);
  nh.Draw("e");
  nh.Print();
  TH1D *contribs=new TH1D("contribs",*label,N_bins,lower,upper);
  
  Int_t NHistos=1;
  Int_t base_index=0;
  TH1D *h[NHistos];
  for (Int_t iHisto=0;iHisto<NHistos;iHisto++) {
    h[iHisto]=new TH1D(Form("h%d",iHisto),*label,N_bins,lower,upper);

//.........这里部分代码省略.........
    label=new TString(";p_{i} (GeV/c);d#sigma/dp_{i} (cm^{2}/(GeV/c))");

    x_leg=0.15;
    N_bins=150;
    lower=0.0;
    upper=0.25;
    break;
  case 4:
    tree_var=new TString("sqrt(pprime[1]**2+pprime[2]**2+pprime[3]**2)");
    nuance_var=new TString("p_hadron[][4]/1.0e3");
    nuance_cut=new TCut("cc && bound && channel==1 && n_hadrons==1 && n_leptons==1");
    label=new TString(";p_{f} (GeV/c);d#sigma/dp_{f} (cm^{2}/(GeV/c))");

    x_leg=0.15;
    N_bins=150;
    lower=0.0;
    upper=0.8;
    break;
  case 5:
    tree_var=new TString("sqrt(pprime[1]**2+pprime[2]**2+pprime[3]**2)");
    nuance_var=new TString("sqrt((p_neutrino[0]-p_lepton[0][0]+p_targ[0])**2+(p_neutrino[1]-p_lepton[0][1]+p_targ[1])**2+(p_neutrino[2]-p_lepton[0][2]+p_targ[2])**2)/1.0e3");
    nuance_cut=new TCut("cc && bound && channel==1 && n_leptons==1");
    label=new TString(";p_{f} (GeV/c);d#sigma/dp_{f} (cm^{2}/(GeV/c))");

    x_leg=0.15;
    N_bins=150;
    lower=0.2;
    upper=0.6;
    //lower=0.2;
    //upper=1.3;
    break;
  }

  TCanvas canvas("canvas","",700,1000);
  canvas.Divide(1,2);
  canvas.cd(1);

  TH1D g0("g0",*label,N_bins,lower,upper);
  g0.Sumw2();
  gtree->Draw(*tree_var+">>g0","","goff");
  g0.Scale(gxs/g0.Integral("width"));
  g0.SetStats(kFALSE);
  g0.Draw("e");

  TH1D nh("nh",*label,N_bins,lower,upper);
  nh.Sumw2();
  nh.SetStats(kFALSE);
  for (Int_t iFile=0;iFile<N_files;iFile++) {
    nu_trees[iFile]->Draw(*nuance_var+">>+nh",*nuance_cut,"goff");
  }
  if (energy_point==300) nh.Scale(0.0033647*8*1.0e-36/nh.Integral("width"));
  if (energy_point==800) nh.Scale(0.0093045*8*1.0e-36/nh.Integral("width"));
  nh.SetLineColor(kRed);
  nh.SetMarkerColor(kRed);
  nh.Draw("esame");

  Int_t NHistos=5;
  TH1D *h[NHistos];
  TH1D *r[NHistos];
  for (Int_t iHisto=0;iHisto<NHistos;iHisto++) {
    h[iHisto]=new TH1D(Form("h%d",iHisto),*label,N_bins,lower,upper);
    h[iHisto]->Sumw2();
  }

  Int_t color=3;
  for (Int_t iHisto=0;iHisto<NHistos;iHisto++) {

void polish_compare(Int_t proc,Int_t mode,TString file) {
  Init();

  //mine
  TFile f(file);
  gROOT->cd();
  TTree *tree=(TTree*)f.Get("tree");
  TGraph *gr=(TGraph*)f.Get("ccqe_rate")->Clone();
  Int_t gr_size=gr->GetN();
  Double_t *graph_proc = new Double_t[gr_size];
  Double_t *graph_xs   = new Double_t[gr_size];
  for (Int_t iProc=0;iProc<gr_size;iProc++) {
    gr->GetPoint(iProc,graph_proc[iProc],graph_xs[iProc]);
  }
  delete gr;

  
  //polish
  TFile f_polish("../ref/polish/O16/graph.root");
  gROOT->cd();
  
  TGraph *gr_pol=0;
  TString *var=0;
  TString *title=0;

  TString *model=0;
  TString legend_string="";
  switch(proc) {
  case 1:
    model=new TString("sm");
    legend_string="Ankowski-Sobczyk Fermi Gas Model";
    break;
  case 2:
    model=new TString("as_mf");
    legend_string="Ankowski-Sobczyk SF (mean field part)";
    break;
  case 3:
    model=new TString("as_corr");
    legend_string="Ankowski-Sobczyk SF (correlated part)";
    break;
  case 23:
    model=new TString("as");
    legend_string="Ankowski-Sobczyk Spectral Function Model";
    break;
  }
  
  Int_t N_bins=0;
  Double_t lower=0.0;
  Double_t upper=0.0;
  Double_t x_leg=0.1;

  if (mode==50) {
    gr_pol=(TGraph*)f_polish.Get("polish_Q2_"+*model)->Clone();
    N_bins=100;
    lower=0.0;
    upper=1.4;
    var=new TString("q[1]**2+q[2]**2+q[3]**2-q[0]**2");
    title=new TString(";Q^{2} (GeV^{2});d#sigma/dQ^{2} (cm^{2}/GeV^{2})");
  }
  
  if (mode==60) {
    gr_pol=(TGraph*)f_polish.Get("polish_e_"+*model)->Clone();
    N_bins=100;
    lower=0.1;
    upper=0.8;
    x_leg=0.1;
    var=new TString("kprime[0]");
    title=new TString(";E_{#mu} (GeV);d#sigma/dE_{#mu} (cm^{2}/GeV)");
  }
  
  if (mode==70) {
    gr_pol=(TGraph*)f_polish.Get("polish_nopb_e_"+*model)->Clone();
    N_bins=100;
    lower=0.1;
    upper=0.8;
    var=new TString("kprime[0]");
    title=new TString(";E_{#mu} (GeV);d#sigma/dE_{#mu} (cm^{2}/GeV)");
  }
  
  f_polish.Close();

  TH1D h1("h1",*title,N_bins,lower,upper);
  h1.Sumw2();
  TH1D h2("h2",*title,N_bins,lower,upper);
  h2.Sumw2();
  TH1D *contribs=(TH1D*)h1.Clone("contribs");
  
  TString cut=Form("process==%d",proc);
  Double_t xs=graph_xs[proc];
  if (proc==23) {
    cut="process==2 || process==3";
    xs=graph_xs[2]+graph_xs[3];
  }
  tree->Draw(*var+">>h1",cut,"goff");
  h1.Scale(xs/h1.Integral("width"));
  
  printf("proc=%d; norm=%8.6g\n",proc,xs);
  
  TCanvas canvas("canvas","",700,1000);
  canvas.Divide(1,2);
//.........这里部分代码省略.........

void NUANCE_compare(Int_t mode,Int_t energy_point,TString file,bool antinu=false) {
  Init();

  //mine
  TFile f(file);
  gROOT->cd();
  TTree *tree=(TTree*)f.Get("tree");
  TGraph *gr=(TGraph*)f.Get("ccqe_rate")->Clone();
  Int_t process=4;
  Double_t xs,dummy;
  gr->GetPoint(process,dummy,xs);
  delete gr;

  //NUANCE
  /*argh--chains are unusable in this ROOT version*/
  Int_t N_files=0;
  if (energy_point== 300) N_files=40;
  if (energy_point== 800) N_files=20;
  if (energy_point==1200) N_files=40;

  TString *tree_var=0;
  TString *nuance_var=0;
  TCut *nuance_cut=0;
  TString *label=0;

  Int_t N_bins=0;
  Double_t lower=0.0;
  Double_t upper=0.0;
  Double_t x_leg=0.0;

  switch (mode) {
  case 1:
    tree_var=new TString("kprime[0]");
    nuance_var=new TString("p_lepton[0][3]/1.0e3");
    nuance_cut=new TCut("cc && bound && channel==1");
    label=new TString(";E_{#mu} (GeV);d#sigma/dE_{#mu} (cm^{2}/GeV)");
    
    x_leg=0.15;
    N_bins=250;
    lower=0.12;
    upper=energy_point/1.0e3;
    break;
  case 2:
    tree_var=new TString("-q[0]**2+q[1]**2+q[2]**2+q[3]**2");
    nuance_var=new TString("-qsq/1.0e6");
    nuance_cut=new TCut("cc && bound && channel==1");
    label=new TString(";Q^{2} (GeV^{2});d#sigma/dQ^{2} (cm^{2}/GeV^{2})");

    x_leg=0.55;
    N_bins=250;
    lower=0.0;
    if (energy_point==300) upper=0.8;
    if (energy_point==800) upper=1.4;
    break;
  case 3:
    tree_var=new TString("mag_p");
    nuance_var=new TString("p_targ[4]/1.0e3");
    nuance_cut=new TCut("cc && bound && channel==1");
    label=new TString(";p_{i} (GeV/c);d#sigma/dp_{i} (cm^{2}/(GeV/c))");

    x_leg=0.15;
    N_bins=150;
    lower=0.0;
    upper=0.25;
    break;
  case 4:
    tree_var=new TString("sqrt(pprime[1]**2+pprime[2]**2+pprime[3]**2)");
    nuance_var=new TString("p_hadron[][4]/1.0e3");
    nuance_cut=new TCut("cc && bound && channel==1 && n_hadrons==1 && n_leptons==1");
    label=new TString(";p_{f} (GeV/c);d#sigma/dp_{f} (cm^{2}/(GeV/c))");

    x_leg=0.15;
    N_bins=150;
    lower=0.0;
    upper=0.8;
    break;
  case 5:
    tree_var=new TString("sqrt(pprime[1]**2+pprime[2]**2+pprime[3]**2)");
    nuance_var=new TString("sqrt((p_neutrino[0]-p_lepton[0][0]+p_targ[0])**2+(p_neutrino[1]-p_lepton[0][1]+p_targ[1])**2+(p_neutrino[2]-p_lepton[0][2]+p_targ[2])**2)/1.0e3");
    nuance_cut=new TCut("cc && bound && channel==1 && n_leptons==1");
    label=new TString(";p_{f} (GeV/c);d#sigma/dp_{f} (cm^{2}/(GeV/c))");

    x_leg=0.15;
    N_bins=150;
    lower=0.2;
    upper=0.6;
    //lower=0.2;
    //upper=1.3;
    break;
  }

  TCanvas canvas("canvas","",700,1000);
  canvas.Divide(1,2);
  canvas.cd(1);

  TH1D nh("nh",*label,N_bins,lower,upper);
  nh.Sumw2();
  nh.SetStats(kFALSE);

  for (Int_t iFile=0;iFile<N_files;iFile++) {
//.........这里部分代码省略.........

void compare6() {
  Init();

  TFile f1("../../events_3.root");
  TTree *tree1=(TTree*)f1.Get("tree");
  TGraph *gr1=(TGraph*)f1.Get("ccqe_rate")->Clone();
  Int_t process1=4;
  Double_t xs1,dummy;
  gr1->GetPoint(process1,dummy,xs1);
  delete gr1;

  TFile f2("../../events_4.root");
  TTree *tree2=(TTree*)f2.Get("tree");
  TGraph *gr2=(TGraph*)f2.Get("ccqe_rate")->Clone();
  Int_t process2=1;
  Double_t xs2;
  gr2->GetPoint(process2,dummy,xs2);
  delete gr2;

  Double_t x_leg=0.15;
  Int_t N_bins=100;
  Double_t lower=0.0;
  Double_t upper=1.2;

  TH1D h1("h1","",N_bins,lower,upper);
  TH1D h2("h2","",N_bins,lower,upper);
  h1.Sumw2();
  h2.Sumw2();
  TH1D *contribs=(TH1D*)h1.Clone("contribs");

  tree1->Draw("-q[0]**2+q[1]**2+q[2]**2+q[3]**2>>h1",Form("process==%d",process1),"goff");
  tree2->Draw("-q[0]**2+q[1]**2+q[2]**2+q[3]**2>>h2",Form("process==%d",process2),"goff");
  h1.Scale(xs1/h1.Integral("width"));
  h2.Scale(xs2/h2.Integral("width"));

  TCanvas canvas("canvas","",700,1000);

  canvas.Divide(1,2);
  canvas.cd(1);

  h1.SetStats(kFALSE);
  h1.GetXaxis()->CenterTitle();
  h1.GetYaxis()->CenterTitle();
  h1.GetYaxis()->SetTitleOffset(1.2);
  h1.SetLineColor(kRed);
  h1.SetMarkerColor(kRed);
  h1.Draw("e");

  h2.SetLineColor(kBlue);
  h2.SetMarkerColor(kBlue);
  h2.Draw("esame");

  TLegend legend(x_leg,0.8,x_leg+0.35,0.9);
  legend.SetBorderSize(0);
  legend.SetFillStyle(0);
  legend.SetHeader("S-M, dipole, FP=0");
  legend.AddEntry(&h1,"my events (no OS,Ep-Eb)");
  legend.AddEntry(&h2,"NUANCE");
  legend.Draw("same");

  chi2_compare(&h1,&h2,1,N_bins,contribs);

  //TLatex text(0.20,0.92,comp_str);
  //text.SetNDC();
  //text.DrawClone();

  canvas.cd(2);
  contribs->Draw();

  canvas.cd(0);
  canvas.DrawClone();

  delete contribs;

}

void MA_compare_800() {
  Init();

  //polish
  TFile f_polish("../ref/polish/O16/graph.root");
  gROOT->cd();
  
  TGraph *gr_pol_benhar=(TGraph*)f_polish.Get("benhar_q2")->Clone();
  TGraph *gr_pol_fg=(TGraph*)f_polish.Get("FG_q2")->Clone();
  f_polish.Close();


  //mine
  Int_t mode=2;

  //TFile f("../../events_5_nofp_800.root");
  TFile f("../../events.root");
  gROOT->cd();
  TTree *tree=(TTree*)f.Get("tree");
  TGraph *gr=(TGraph*)f.Get("ccqe_rate")->Clone();
  Int_t process=4;
  Double_t xs,dummy;
  gr->GetPoint(process,dummy,xs);
  delete gr;

  TString *tree_var=0;
  TString *label=0;

  Int_t N_bins=0;
  Double_t lower=0.0;
  Double_t upper=0.0;
  Double_t x_leg=0.0;

  switch (mode) {
  case 1:
    tree_var=new TString("kprime[0]");
    label=new TString(";E_{#mu} (GeV);d#sigma/dE_{#mu} (cm^{2}/GeV)");
    
    x_leg=0.15;
    N_bins=70;
    lower=0.12;
    upper=0.8;
    break;
  case 2:
    tree_var=new TString("-q[0]**2+q[1]**2+q[2]**2+q[3]**2");
    label=new TString(";Q^{2} (GeV^{2});d#sigma/dQ^{2} (cm^{2}/GeV^{2})");

    x_leg=0.55;
    N_bins=70;
    lower=0.0;
    upper=1.4;
    break;
  case 3:
    tree_var=new TString("mag_p");
    label=new TString(";p_{i} (GeV/c);d#sigma/dp_{i} (cm^{2}/(GeV/c))");

    x_leg=0.15;
    N_bins=150;
    lower=0.0;
    upper=0.25;
    break;
  case 4:
    tree_var=new TString("sqrt(pprime[1]**2+pprime[2]**2+pprime[3]**2)");
    label=new TString(";p_{f} (GeV/c);d#sigma/dp_{f} (cm^{2}/(GeV/c))");

    x_leg=0.15;
    N_bins=150;
    lower=0.0;
    upper=0.8;
    break;
  case 5:
    tree_var=new TString("sqrt(pprime[1]**2+pprime[2]**2+pprime[3]**2)");
    label=new TString(";p_{f} (GeV/c);d#sigma/dp_{f} (cm^{2}/(GeV/c))");

    x_leg=0.15;
    N_bins=150;
    lower=0.2;
    upper=0.6;
    //lower=0.2;
    //upper=1.3;
    break;
  }

  TCanvas canvas("canvas","",700,1000);
  canvas.Divide(1,2);
  canvas.cd(1);

  TH1D g_benhar("g_benhar",*label,N_bins,lower,upper);
  TH1D g_fg    ("g_fg",    *label,N_bins,lower,upper);
  g_benhar.Sumw2();
  g_fg.Sumw2();

  histo_graph(&g_benhar,gr_pol_benhar,4000000);
  histo_graph(&g_fg,gr_pol_fg,4000000);
  if (gr_pol_benhar) delete gr_pol_benhar;
  if (gr_pol_fg)     delete gr_pol_fg;

  g_fg.SetStats(kFALSE);
  g_benhar.SetStats(kFALSE);
  g_fg.SetLineColor(kRed);
//.........这里部分代码省略.........

PfPvPlot::PfPvPlot(MainWindow *mainWindow)
    : rideItem (NULL), mainWindow(mainWindow), cp_ (0), cad_ (85), cl_ (0.175), shade_zones(true)
{
    setInstanceName("PfPv Plot");

    setCanvasBackground(Qt::white);
    canvas()->setFrameStyle(QFrame::NoFrame);

    setAxisTitle(yLeft, tr("Average Effective Pedal Force (N)"));
    setAxisScale(yLeft, 0, 600);
    setAxisTitle(xBottom, tr("Circumferential Pedal Velocity (m/s)"));
    setAxisScale(xBottom, 0, 3);
    setAxisMaxMinor(yLeft, 0);
    setAxisMaxMinor(xBottom, 0);
    QwtScaleDraw *sd = new QwtScaleDraw;
    sd->setTickLength(QwtScaleDiv::MajorTick, 3);
    setAxisScaleDraw(xBottom, sd);
    sd = new QwtScaleDraw;
    sd->setTickLength(QwtScaleDiv::MajorTick, 3);
    setAxisScaleDraw(yLeft, sd);

    mX = new QwtPlotMarker();
    mX->setLineStyle(QwtPlotMarker::VLine);
    mX->attach(this);

    mY = new QwtPlotMarker();
    mY->setLineStyle(QwtPlotMarker::HLine);
    mY->attach(this);

    cpCurve = new QwtPlotCurve();
    cpCurve->setRenderHint(QwtPlotItem::RenderAntialiased);
    cpCurve->attach(this);

    curve = new QwtPlotCurve();
    curve->attach(this);

    cl_ = appsettings->value(this, GC_CRANKLENGTH).toDouble() / 1000.0;

    // markup timeInQuadrant
    tiqMarker[0] = new QwtPlotMarker(); tiqMarker[0]->attach(this);
    tiqMarker[0]->setXValue(2.9);
    tiqMarker[0]->setYValue(580);

    tiqMarker[1] = new QwtPlotMarker(); tiqMarker[1]->attach(this);
    tiqMarker[1]->setXValue(0.1);
    tiqMarker[1]->setYValue(580);

    tiqMarker[2] = new QwtPlotMarker(); tiqMarker[2]->attach(this);
    tiqMarker[2]->setXValue(0.1);
    tiqMarker[2]->setYValue(10);

    tiqMarker[3] = new QwtPlotMarker(); tiqMarker[3]->attach(this);
    tiqMarker[3]->setXValue(2.9);
    tiqMarker[3]->setYValue(10);

    merge_intervals = false;
    frame_intervals = true;

    // only default on first time through, after this the user may have adjusted
    if (appsettings->value(this, GC_SHADEZONES, true).toBool()==false) shade_zones = false;
    else shade_zones = true;

    configChanged();

    recalc();
}

int main(int argc, char** argv) {
    SkCommandLineFlags::SetUsage(
            "Usage: visualize_color_gamut --input <path to input image> "
                                         "--output <path to output image> "
                                         "--sRGB <draw canonical sRGB gamut> "
                                         "--adobeRGB <draw canonical Adobe RGB gamut> "
                                         "--uncorrected <path to reencoded, uncorrected "
                                         "               input image>\n"
            "Description: Writes a visualization of the color gamut to the output image  ."
                         "Also, if a path is provided, writes uncorrected bytes to an unmarked "
                         "png, for comparison with the input image.\n");
    SkCommandLineFlags::Parse(argc, argv);
    const char* input = FLAGS_input[0];
    const char* output = FLAGS_output[0];
    if (!input || !output) {
        SkCommandLineFlags::PrintUsage();
        return -1;
    }

    SkAutoTUnref<SkData> data(SkData::NewFromFileName(input));
    if (!data) {
        SkDebugf("Cannot find input image.\n");
        return -1;
    }
    SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data));
    if (!codec) {
        SkDebugf("Invalid input image.\n");
        return -1;
    }

    // Load a graph of the CIE XYZ color gamut.
    SkBitmap gamut;
    if (!GetResourceAsBitmap("gamut.png", &gamut)) {
        SkDebugf("Program failure.\n");
        return -1;
    }
    SkCanvas canvas(gamut);

    // Draw the sRGB gamut if requested.
    if (FLAGS_sRGB) {
        sk_sp<SkColorSpace> sRGBSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
        draw_gamut(&canvas, sRGBSpace->xyz(), "sRGB", 0xFFFF9394, false);
    }

    // Draw the Adobe RGB gamut if requested.
    if (FLAGS_adobeRGB) {
        sk_sp<SkColorSpace> adobeRGBSpace = SkColorSpace::NewNamed(SkColorSpace::kAdobeRGB_Named);
        draw_gamut(&canvas, adobeRGBSpace->xyz(), "Adobe RGB", 0xFF31a9e1, false);
    }

    // Draw gamut for the input image.
    sk_sp<SkColorSpace> colorSpace = sk_ref_sp(codec->getInfo().colorSpace());
    if (!colorSpace) {
        SkDebugf("Image had no embedded color space information.  Defaulting to sRGB.\n");
        colorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
    }
    draw_gamut(&canvas, colorSpace->xyz(), input, 0xFF000000, true);

    // Finally, encode the result to the output file.
    SkAutoTUnref<SkData> out(SkImageEncoder::EncodeData(gamut, SkImageEncoder::kPNG_Type, 100));
    if (!out) {
        SkDebugf("Failed to encode gamut output.\n");
        return -1;
    }
    SkFILEWStream stream(output);
    bool result = stream.write(out->data(), out->size());
    if (!result) {
        SkDebugf("Failed to write gamut output.\n");
        return -1;
    }

    // Also, if requested, decode and reencode the uncorrected input image.
    if (!FLAGS_uncorrected.isEmpty()) {
        SkBitmap bitmap;
        int width = codec->getInfo().width();
        int height = codec->getInfo().height();
        SkAlphaType alphaType = codec->getInfo().alphaType();
        bitmap.allocN32Pixels(width, height, kOpaque_SkAlphaType == alphaType);
        SkImageInfo decodeInfo = SkImageInfo::MakeN32(width, height, alphaType);
        if (SkCodec::kSuccess != codec->getPixels(decodeInfo, bitmap.getPixels(),
                                                  bitmap.rowBytes())) {
            SkDebugf("Could not decode input image.\n");
            return -1;
        }
        out.reset(SkImageEncoder::EncodeData(bitmap, SkImageEncoder::kPNG_Type, 100));
        if (!out) {
            SkDebugf("Failed to encode uncorrected image.\n");
            return -1;
        }
        SkFILEWStream bitmapStream(FLAGS_uncorrected[0]);
        result = bitmapStream.write(out->data(), out->size());
        if (!result) {
            SkDebugf("Failed to write uncorrected image output.\n");
            return -1;
        }
    }

    return 0;
}

int App::start(const std::vector<std::string> &args)
{
	clan::DisplayWindowDescription description;
	description.set_title("Shockwave Shader");
	description.set_size(clan::Size(1024, 768), true);

	clan::DisplayWindow window(description);
	clan::InputDevice keyboard = window.get_ic().get_keyboard();
	clan::Canvas canvas(window);
    clan::SlotContainer cc;

	cc.connect(window.get_ic().get_keyboard().sig_key_up(), clan::bind_member(this, &App::on_input_up));

	cc.connect(window.sig_window_close(), clan::bind_member(this, &App::window_close));

	// Create offscreen texture
	clan::Texture2D texture_offscreen(canvas, canvas.get_width(), canvas.get_height());
	texture_offscreen.set_min_filter(clan::filter_nearest);
	texture_offscreen.set_mag_filter(clan::filter_nearest);

	// Create offscreen framebuffer
	clan::FrameBuffer framebuffer_offscreen(canvas);
	framebuffer_offscreen.attach_color(0, texture_offscreen);
	clan::Canvas canvas_offscreen(canvas, framebuffer_offscreen);

	clan::Image background(canvas, "../PostProcessing/Resources/background.png");
	clan::Image ball(canvas, "../PostProcessing/Resources/ball.png");
	ball.set_alignment(clan::origin_center);

	// Load and link shaders
	clan::ProgramObject shader = clan::ProgramObject::load(canvas, "Resources/vertex_shader.glsl", "Resources/fragment_shader.glsl");
	shader.bind_attribute_location(0, "Position");
	shader.bind_attribute_location(1, "TexCoord0");
	shader.bind_frag_data_location(0, "cl_FragColor");

	if (!shader.link())
		throw clan::Exception("Unable to link shader program: Error:" + shader.get_info_log());
	shader.set_uniform1i("Texture0", 0);

	quit = false;

	float amount = 0.0f;
	timer = 0.0f;

	float scale = 1.0f;

	clan::Font font(canvas, "tahoma", 32);

	// Shader idea and code from http://www.geeks3d.com/20091116/shader-library-2d-shockwave-post-processing-filter-glsl/
	// Shader enhanced for clanlib

	gpu_positions = clan::VertexArrayVector<clan::Vec2f>(canvas, 6);
	gpu_tex1_coords = clan::VertexArrayVector<clan::Vec2f>(canvas, 6);
	gpu_uniforms = clan::UniformVector<ProgramUniforms>(canvas, 1);
	gpu_primitives_array = clan::PrimitivesArray(canvas);
	gpu_primitives_array.set_attributes(0, gpu_positions);
	gpu_primitives_array.set_attributes(1, gpu_tex1_coords);

	uniforms.shockParams = clan::Vec3f(10.0f, 0.8f, 0.1f);

	clan::ubyte64 startTime = clan::System::get_time();
	shockwave_start_time = 0.0f;
	shockwave_rate = 1.0f;
	uniforms.glow = 0.1f;

	while (!quit)
	{
		timer = (clan::System::get_time() - startTime) / 1000.0f;

		uniforms.time = (timer - shockwave_start_time) / shockwave_rate;

		// Render standard image to offscreen buffer
		background.draw(canvas_offscreen, 0, 0);
		float xpos = canvas.get_width() / 2 + 200 * sinf(timer / 2.0f);
		float ypos = canvas.get_height() / 2 + 200 * cosf(timer / 2.0f);
		ball.draw(canvas_offscreen, xpos, ypos);
		canvas_offscreen.flush();

		uniforms.center.x = xpos / ((float) canvas.get_width());
		uniforms.center.y = ypos / ((float) canvas.get_height());

		render_shockwave(canvas, texture_offscreen, shader);

		const int gap = 32;
		font.draw_text(canvas, 10, 64 + gap*0, "Press 'M' to emit a shockwave");
		font.draw_text(canvas, 10, 64 + gap*1, "base: " + clan::StringHelp::float_to_text(uniforms.shockParams.x) + " (Press Q,W)");
		font.draw_text(canvas, 10, 64 + gap*2, "exponent: " + clan::StringHelp::float_to_text(uniforms.shockParams.y) + " (Press A,S)");
		font.draw_text(canvas, 10, 64 + gap*3, "distance: " + clan::StringHelp::float_to_text(uniforms.shockParams.z) + " (Press Z,X)");
		font.draw_text(canvas, 10, 64 + gap*4, "rate: " + clan::StringHelp::float_to_text(shockwave_rate) + " (Press E,R)");
		font.draw_text(canvas, 10, 64 + gap*5, "glow: " + clan::StringHelp::float_to_text(uniforms.glow) + " (Press D,F)");

		window.flip();

		clan::System::sleep(10);

		clan::KeepAlive::process();
	}

	return 0;
}