![(please configure the [header_logo] section in trac.ini)](/PI/chrome/site/your_project_logo.png){kind=logo}
Changeset 914 in Sophya for trunk/SophyaLib/HiStats/histos2.cc
- Timestamp:
- Apr 13, 2000, 6:04:50 PM (25 years ago)
- File:
-
- 1 edited
-
trunk/SophyaLib/HiStats/histos2.cc (modified) (84 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/SophyaLib/HiStats/histos2.cc
r763 r914 16 16 #include "generalfit.h" 17 17 18 //++ 19 // Class Histo2D 20 // Lib Outils++ 21 // include histos2.h 22 // 23 // Classe d'histogrammes 2D 24 //-- 25 26 /////////////////////////////////////////////////////////////////// 27 //++ 28 // Titre Constructeurs 29 //-- 30 31 //++ 18 /////////////////////////////////////////////////////////////////// 19 /*! 20 Createur d'un histogramme 2D ayant nxBin,nyBin bins 21 entre xMin,xMax et yMin,yMax. 22 */ 32 23 Histo2D::Histo2D(float xMin, float xMax, int nxBin 33 24 ,float yMin, float yMax, int nyBin) 34 //35 // Createur d'un histogramme 2D ayant nxBin,nyBin bins36 // entre xMin,xMax et yMin,yMax.37 //--38 25 : data(new float[nxBin*nyBin]), err2(NULL) 39 26 , nHist(0), nEntries(0) … … 50 37 } 51 38 52 //++ 39 /*! 40 Constructeur par copie. 41 */ 53 42 Histo2D::Histo2D(const Histo2D& h) 54 //55 // Constructeur par copie.56 //--57 43 { 58 44 int i,j; … … 118 104 } 119 105 120 //++ 106 /*! 107 Constructeur par defaut. 108 */ 121 109 Histo2D::Histo2D() 122 //123 // Constructeur par defaut.124 //--125 110 : data(NULL), err2(NULL) 126 111 , nHist(0), nEntries(0) … … 136 121 137 122 /////////////////////////////////////////////////////////////////// 138 //++ 123 /*! 124 Desallocation de la place de l'histogramme (fct privee). 125 */ 139 126 void Histo2D::Delete() 140 //141 // Desallocation de la place de l'histogramme (fct privee).142 //--143 127 { 144 128 if( data != NULL ) { delete[] data; data = NULL;} … … 163 147 } 164 148 165 //++ 149 /*! 150 Destructeur. 151 */ 166 152 Histo2D::~Histo2D() 167 //168 // Destructeur.169 //--170 153 { 171 154 Delete(); … … 173 156 174 157 /////////////////////////////////////////////////////////////////// 175 //++ 176 // Titre Methodes generales 177 //-- 178 179 //++ 158 /*! 159 Remise a zero du contenu, des erreurs et des valeurs. 160 */ 180 161 void Histo2D::Zero() 181 //182 // Remise a zero du contenu, des erreurs et des valeurs.183 //--184 162 { 185 163 nHist = nEntries = 0; … … 200 178 201 179 /////////////////////////////////////////////////////////////////// 202 //++ 180 /*! 181 Pour avoir le calcul des erreurs. 182 */ 203 183 void Histo2D::Errors() 204 //205 // Pour avoir le calcul des erreurs.206 //--207 184 { 208 185 if( nxy > 0 ) { … … 213 190 214 191 /////////////////////////////////////////////////////////////////// 215 //++ 192 /*! 193 Operateur H2 = H1 194 */ 216 195 Histo2D& Histo2D::operator = (const Histo2D& h) 217 //218 //--219 196 { 220 197 int i,j,nb; … … 286 263 287 264 /////////////////////////////////////////////////////////////////// 288 //++ 265 /*! 266 Operateur H *= b 267 */ 289 268 Histo2D& Histo2D::operator *= (double b) 290 //291 //--292 269 { 293 270 int i,j; … … 310 287 } 311 288 312 //++ 289 /*! 290 Operateur H /= b 291 */ 313 292 Histo2D& Histo2D::operator /= (double b) 314 //315 //--316 293 { 317 294 int i,j; … … 335 312 } 336 313 337 //++ 314 /*! 315 Operateur H += b 316 */ 338 317 Histo2D& Histo2D::operator += (double b) 339 //340 //--341 318 { 342 319 int i,j; … … 362 339 } 363 340 364 //++ 341 /*! 342 Operateur H -= b 343 */ 365 344 Histo2D& Histo2D::operator -= (double b) 366 //367 //--368 345 { 369 346 int i,j; … … 390 367 391 368 /////////////////////////////////////////////////////////////////// 392 //++ 369 /*! 370 Operateur H2 = H1 * b 371 */ 393 372 Histo2D operator * (const Histo2D& a, double b) 394 //395 //--396 373 { 397 374 Histo2D result(a); … … 399 376 } 400 377 401 //++ 378 /*! 379 Operateur H2 = b * H1 380 */ 402 381 Histo2D operator * (double b, const Histo2D& a) 403 //404 //--405 382 { 406 383 Histo2D result(a); … … 408 385 } 409 386 410 //++ 387 /*! 388 Operateur H2 = H1 / b 389 */ 411 390 Histo2D operator / (const Histo2D& a, double b) 412 //413 //--414 391 { 415 392 Histo2D result(a); … … 417 394 } 418 395 419 //++ 396 /*! 397 Operateur H2 = H1 + b 398 */ 420 399 Histo2D operator + (const Histo2D& a, double b) 421 //422 //--423 400 { 424 401 Histo2D result(a); … … 426 403 } 427 404 428 //++ 405 /*! 406 Operateur H2 = b + H1 407 */ 429 408 Histo2D operator + (double b, const Histo2D& a) 430 //431 //--432 409 { 433 410 Histo2D result(a); … … 435 412 } 436 413 437 //++ 414 /*! 415 Operateur H2 = H1 - b 416 */ 438 417 Histo2D operator - (const Histo2D& a, double b) 439 //440 //--441 418 { 442 419 Histo2D result(a); … … 444 421 } 445 422 446 //++ 423 /*! 424 Operateur H2 = b - H1 425 */ 447 426 Histo2D operator - (double b, const Histo2D& a) 448 //449 //--450 427 { 451 428 Histo2D result(a); … … 455 432 456 433 /////////////////////////////////////////////////////////////////// 457 //++ 434 /*! 435 Operateur H += H1 436 */ 458 437 Histo2D& Histo2D::operator += (const Histo2D& a) 459 //460 //--461 438 { 462 439 int i,j; … … 478 455 } 479 456 480 //++ 457 /*! 458 Operateur H -= H1 459 */ 481 460 Histo2D& Histo2D::operator -= (const Histo2D& a) 482 //483 //--484 461 { 485 462 int i,j; … … 501 478 } 502 479 503 //++ 480 /*! 481 Operateur H *= H1 482 */ 504 483 Histo2D& Histo2D::operator *= (const Histo2D& a) 505 //506 //--507 484 { 508 485 int i,j; … … 526 503 } 527 504 528 //++ 505 /*! 506 Operateur H /= H1 507 */ 529 508 Histo2D& Histo2D::operator /= (const Histo2D& a) 530 //531 //--532 509 { 533 510 int i,j; … … 559 536 560 537 /////////////////////////////////////////////////////////////////// 561 //++ 538 /*! 539 Operateur H = H1 + H2 540 */ 541 562 542 Histo2D operator + (const Histo2D& a, const Histo2D& b) 563 //564 //--565 543 { 566 544 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr); … … 569 547 } 570 548 571 //++ 549 /*! 550 Operateur H = H1 - H2 551 */ 572 552 Histo2D operator - (const Histo2D& a, const Histo2D& b) 573 //574 //--575 553 { 576 554 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr); … … 579 557 } 580 558 581 //++ 559 /*! 560 Operateur H = H1 * H2 561 */ 582 562 Histo2D operator * (const Histo2D& a, const Histo2D& b) 583 //584 //--585 563 { 586 564 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr); … … 589 567 } 590 568 591 //++ 569 /*! 570 Operateur H = H1 / H2 571 */ 592 572 Histo2D operator / (const Histo2D& a, const Histo2D& b) 593 //594 //--595 573 { 596 574 if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr); … … 600 578 601 579 /////////////////////////////////////////////////////////////////// 602 //++ 580 /*! 581 Remplissage d'un tableau avec les valeurs des abscisses. 582 */ 603 583 void Histo2D::GetXCoor(Vector &v) 604 //605 // Remplissage d'un tableau avec les valeurs des abscisses.606 //--607 584 { 608 585 float x,y; … … 612 589 } 613 590 614 //++ 591 /*! 592 Remplissage d'un tableau avec les valeurs des ordonnees. 593 */ 615 594 void Histo2D::GetYCoor(Vector &v) 616 //617 // Remplissage d'un tableau avec les valeurs des ordonnees.618 //--619 595 { 620 596 float x,y; … … 624 600 } 625 601 626 //++ 627 //| Remarque sur les indices: 628 //| H(i,j) -> i = coord x (0<i<nx), j = coord y (0<j<ny) 629 //| v(ii,jj) -> ii = ligne (0<i<NRows()), jj = colonne (0<i<NCol()) 630 //| On fait une correspondance directe i<->ii et j<->jj 631 //| ce qui, en representation classique des histos2D et des matrices 632 //| entraine une inversion x<->y cad une symetrie / diagonale principale 633 //| H(0,...) represente ^ mais v(0,...) represente 634 //| |x....... |xxxxxxxx| 635 //| |x....... |........| 636 //| |x....... |........| 637 //| |x....... |........| 638 //| |x....... |........| 639 //| ---------> 640 //| colonne no 1 ligne no 1 641 //-- 642 643 //++ 602 /*! 603 Remplissage d'un tableau avec les valeurs du contenu. 604 */ 644 605 void Histo2D::GetValue(Matrix &v) 645 //646 // Remplissage d'un tableau avec les valeurs du contenu.647 //--648 606 { 649 607 v.Realloc(nx,ny); … … 653 611 } 654 612 655 //++ 613 /*! 614 Remplissage d'un tableau avec les valeurs du carre des erreurs. 615 */ 656 616 void Histo2D::GetError2(Matrix &v) 657 //658 // Remplissage d'un tableau avec les valeurs du carre des erreurs.659 //--660 617 { 661 618 int i,j; … … 667 624 } 668 625 669 //++ 626 /*! 627 Remplissage d'un tableau avec les valeurs des erreurs. 628 */ 670 629 void Histo2D::GetError(Matrix &v) 671 //672 // Remplissage d'un tableau avec les valeurs des erreurs.673 //--674 630 { 675 631 int i,j; … … 682 638 683 639 /////////////////////////////////////////////////////////////////// 684 //++ 640 /*! 641 Remplissage du contenu de l'histo avec les valeurs d'un tableau. 642 */ 685 643 void Histo2D::PutValue(Matrix &v, int ierr) 686 //687 // Remplissage du contenu de l'histo avec les valeurs d'un tableau.688 //--689 644 { 690 645 int i,j; … … 697 652 } 698 653 699 //++ 654 /*! 655 Addition du contenu de l'histo avec les valeurs d'un tableau. 656 */ 700 657 void Histo2D::PutValueAdd(Matrix &v, int ierr) 701 //702 // Addition du contenu de l'histo avec les valeurs d'un tableau.703 //--704 658 { 705 659 int i,j; … … 712 666 } 713 667 714 //++ 668 /*! 669 Remplissage des erreurs au carre de l'histo 670 avec les valeurs d'un tableau. 671 */ 715 672 void Histo2D::PutError2(Matrix &v) 716 //717 // Remplissage des erreurs au carre de l'histo718 // avec les valeurs d'un tableau.719 //--720 673 { 721 674 int i,j; … … 726 679 } 727 680 728 //++ 681 /*! 682 Addition des erreurs au carre de l'histo 683 avec les valeurs d'un tableau. 684 */ 729 685 void Histo2D::PutError2Add(Matrix &v) 730 //731 // Addition des erreurs au carre de l'histo732 // avec les valeurs d'un tableau.733 //--734 686 { 735 687 int i,j; … … 741 693 } 742 694 743 //++ 695 /*! 696 Remplissage des erreurs de l'histo avec les valeurs d'un tableau. 697 */ 744 698 void Histo2D::PutError(Matrix &v) 745 //746 // Remplissage des erreurs de l'histo avec les valeurs d'un tableau.747 //--748 699 { 749 700 int i,j; … … 757 708 /////////////////////////////////////////////////////////////////// 758 709 /********* Methode *********/ 759 //++ 710 /*! 711 Addition du contenu de l'histo pour x,y poids w. 712 */ 760 713 void Histo2D::Add(float x, float y, float w) 761 //762 // Addition du contenu de l'histo pour x,y poids w.763 //--764 714 { 765 715 list<bande_slice>::iterator it; … … 801 751 802 752 /////////////////////////////////////////////////////////////////// 803 //++ 753 /*! 754 Recherche du bin du maximum dans le pave [il,ih][jl,jh]. 755 */ 804 756 void Histo2D::IJMax(int& imax,int& jmax,int il,int ih,int jl,int jh) 805 //806 // Recherche du bin du maximum dans le pave [il,ih][jl,jh].807 //--808 757 { 809 758 if( il > ih ) { il = 0; ih = nx-1; } … … 823 772 } 824 773 825 //++ 774 /*! 775 Recherche du bin du minimum dans le pave [il,ih][jl,jh]. 776 */ 826 777 void Histo2D::IJMin(int& imax,int& jmax,int il,int ih,int jl,int jh) 827 //828 // Recherche du bin du minimum dans le pave [il,ih][jl,jh].829 //--830 778 { 831 779 if( il > ih ) { il = 0; ih = nx-1; } … … 846 794 847 795 848 //++ 796 /*! 797 Recherche du maximum dans le pave [il,ih][jl,jh]. 798 */ 849 799 float Histo2D::VMax(int il,int ih,int jl,int jh) const 850 //851 // Recherche du maximum dans le pave [il,ih][jl,jh].852 //--853 800 { 854 801 if( il > ih ) { il = 0; ih = nx-1; } … … 867 814 } 868 815 869 //++ 816 /*! 817 Recherche du minimum dans le pave [il,ih][jl,jh]. 818 */ 870 819 float Histo2D::VMin(int il,int ih,int jl,int jh) const 871 //872 // Recherche du minimum dans le pave [il,ih][jl,jh].873 //--874 820 { 875 821 if( il > ih ) { il = 0; ih = nx-1; } … … 889 835 890 836 /////////////////////////////////////////////////////////////////// 891 //++ 837 /*! 838 Renvoie les under.overflow dans les 8 quadrants. 839 \verbatim 840 over[3][3]: 20 | 21 | 22 841 | | 842 -------------- 843 | | 844 10 | 11 | 12 11 = all overflow+underflow 845 | | 846 -------------- 847 | | 848 00 | 01 | 02 849 \endverbatim 850 */ 892 851 float Histo2D::NOver(int i,int j) const 893 //894 // Renvoie les under.overflow dans les 8 quadrants.895 //| over[3][3]: 20 | 21 | 22896 //| | |897 //| --------------898 //| | |899 //| 10 | 11 | 12 11 = all overflow+underflow900 //| | |901 //| --------------902 //| | |903 //| 00 | 01 | 02904 //--905 852 { 906 853 if( i < 0 || i>=3 || j < 0 || j>=3 ) return over[1][1]; … … 910 857 911 858 /////////////////////////////////////////////////////////////////// 912 //++ 859 /*! 860 Retourne le nombre de bins non-nuls. 861 */ 913 862 int Histo2D::BinNonNul() const 914 //915 // Retourne le nombre de bins non-nuls.916 //--917 863 { 918 864 int non=0; … … 921 867 } 922 868 923 //++ 869 /*! 870 Retourne le nombre de bins avec erreurs non-nulles. 871 */ 924 872 int Histo2D::ErrNonNul() const 925 //926 // Retourne le nombre de bins avec erreurs non-nulles.927 //--928 873 { 929 874 if(err2==NULL) return -1; … … 934 879 935 880 /////////////////////////////////////////////////////////////////// 936 //++ 881 /*! 882 Idem EstimeMax(int...) mais retourne x,y. 883 */ 937 884 int Histo2D::EstimeMax(float& xm,float& ym,int SzPav 938 885 ,int il,int ih,int jl,int jh) 939 //940 // Idem EstimeMax(int...) mais retourne x,y.941 //--942 886 { 943 887 int im,jm; … … 946 890 } 947 891 948 //++ 892 /*! 893 Determine les abscisses et ordonnees du maximum donne par im,jm 894 en moyennant dans un pave SzPav x SzPav autour du maximum. 895 \verbatim 896 Return: 897 0 = si fit maximum reussi avec SzPav pixels 898 1 = si fit maximum reussi avec moins que SzPav pixels 899 dans au moins 1 direction 900 2 = si fit maximum echoue et renvoit BinCenter() 901 -1 = si echec: SzPav <= 0 ou im,jm hors limites 902 \endverbatim 903 */ 949 904 int Histo2D::EstimeMax(int im,int jm,float& xm,float& ym,int SzPav) 950 //951 // Determine les abscisses et ordonnees du maximum donne par im,jm952 // en moyennant dans un pave SzPav x SzPav autour du maximum.953 //| Return:954 //| 0 = si fit maximum reussi avec SzPav pixels955 //| 1 = si fit maximum reussi avec moins que SzPav pixels956 //| dans au moins 1 direction957 //| 2 = si fit maximum echoue et renvoit BinCenter()958 //| -1 = si echec: SzPav <= 0 ou im,jm hors limites959 //--960 905 { 961 906 xm = ym = 0; … … 992 937 } 993 938 994 //++ 939 /*! 940 Pour trouver le maximum de l'histogramme en tenant compte 941 des fluctuations. 942 \verbatim 943 Methode: 944 1-/ On recherche le bin maximum MAX de l'histogramme 945 2-/ On considere que tous les pixels compris entre [MAX-Dz,MAX] 946 peuvent etre des pixels maxima. 947 3-/ On identifie le bin maximum en choissisant le pixel du 2-/ 948 tel que la somme des pixels dans un pave SzPav x SzPav soit maximale. 949 INPUT: 950 SzPav = taille du pave pour departager 951 Dz = tolerance pour identifier tous les pixels "maximum" 952 OUTPUT: 953 im,jm = pixel maximum trouve 954 RETURN: 955 <0 = Echec 956 >0 = nombre de pixels possibles pour le maximum 957 \endverbatim 958 */ 995 959 int Histo2D::FindMax(int& im,int& jm,int SzPav,float Dz 996 960 ,int il,int ih,int jl,int jh) 997 //998 // Pour trouver le maximum de l'histogramme en tenant compte999 // des fluctuations.1000 //| Methode:1001 //| 1-/ On recherche le bin maximum MAX de l'histogramme1002 //| 2-/ On considere que tous les pixels compris entre [MAX-Dz,MAX]1003 //| peuvent etre des pixels maxima.1004 //| 3-/ On identifie le bin maximum en choissisant le pixel du 2-/1005 //| tel que la somme des pixels dans un pave SzPav x SzPav soit maximale.1006 //| INPUT:1007 //| SzPav = taille du pave pour departager1008 //| Dz = tolerance pour identifier tous les pixels "maximum"1009 //| OUTPUT:1010 //| im,jm = pixel maximum trouve1011 //| RETURN:1012 //| <0 = Echec1013 //| >0 = nombre de pixels possibles pour le maximum1014 //--1015 961 { 1016 962 if( il > ih ) { il = 0; ih = nx-1; } … … 1046 992 1047 993 ////////////////////////////////////////////////////////// 1048 //++ 994 /*! 995 Fit de l'histogramme par ``gfit''. 996 \verbatim 997 typ_err = 0 : 998 - erreur attachee au bin si elle existe 999 - sinon 1 1000 typ_err = 1 : 1001 - erreur attachee au bin si elle existe 1002 - sinon max( sqrt(abs(bin) ,1 ) 1003 typ_err = 2 : 1004 - erreur forcee a 1 1005 typ_err = 3 : 1006 - erreur forcee a max( sqrt(abs(bin) ,1 ) 1007 typ_err = 4 : 1008 - erreur forcee a 1, nulle si bin a zero. 1009 typ_err = 5 : 1010 - erreur forcee a max( sqrt(abs(bin) ,1 ), 1011 nulle si bin a zero. 1012 \endverbatim 1013 */ 1049 1014 int Histo2D::Fit(GeneralFit& gfit,unsigned short typ_err) 1050 //1051 // Fit de l'histogramme par ``gfit''.1052 //| typ_err = 0 :1053 //| - erreur attachee au bin si elle existe1054 //| - sinon 11055 //| typ_err = 1 :1056 //| - erreur attachee au bin si elle existe1057 //| - sinon max( sqrt(abs(bin) ,1 )1058 //| typ_err = 2 :1059 //| - erreur forcee a 11060 //| typ_err = 3 :1061 //| - erreur forcee a max( sqrt(abs(bin) ,1 )1062 //| typ_err = 4 :1063 //| - erreur forcee a 1, nulle si bin a zero.1064 //| typ_err = 5 :1065 //| - erreur forcee a max( sqrt(abs(bin) ,1 ),1066 //| nulle si bin a zero.1067 //--1068 1015 { 1069 1016 if(NBinX()*NBinY()<=0) return -1000; … … 1092 1039 } 1093 1040 1094 //++ 1041 /*! 1042 Retourne une classe contenant les residus du fit ``gfit''. 1043 */ 1095 1044 Histo2D Histo2D::FitResidus(GeneralFit& gfit) 1096 //1097 // Retourne une classe contenant les residus du fit ``gfit''.1098 //--1099 1045 { 1100 1046 if(NBinX()<=0 || NBinY()<=0) … … 1114 1060 } 1115 1061 1116 //++ 1062 /*! 1063 Retourne une classe contenant la fonction du fit ``gfit''. 1064 */ 1117 1065 Histo2D Histo2D::FitFunction(GeneralFit& gfit) 1118 //1119 // Retourne une classe contenant la fonction du fit ``gfit''.1120 //--1121 1066 { 1122 1067 if(NBinX()<=0 || NBinY()<=0) … … 1137 1082 1138 1083 /////////////////////////////////////////////////////////////////// 1139 //++ 1084 /*! 1085 Impression des informations sur l'histogramme. 1086 */ 1140 1087 void Histo2D::PrintStatus() 1141 //1142 // Impression des informations sur l'histogramme.1143 //--1144 1088 { 1145 1089 printf("~Histo::Print nHist=%g nEntries=%d\n",nHist,nEntries); … … 1153 1097 1154 1098 /////////////////////////////////////////////////////////////////// 1155 //++ 1099 /*! 1100 Impression de l'histogramme sur stdout entre [il,ih] et [jl,jh]. 1101 \verbatim 1102 numero d'index: 00000000001111111111222222222233333 1103 01234567890123456789012345678901234 1104 valeur entiere: 00000000001111111111222222222233333 1105 12345678901234567890123456789012345 1106 \endverbatim 1107 */ 1156 1108 void Histo2D::Print(float min,float max 1157 1109 ,int il,int ih,int jl,int jh) 1158 //1159 // Impression de l'histogramme sur stdout entre [il,ih] et [jl,jh].1160 //--1161 1110 { 1162 1111 int ns = 35; 1163 // numero d'index: 000000000011111111112222222222333331164 // 012345678901234567890123456789012341165 // valeur entiere: 000000000011111111112222222222333331166 // 123456789012345678901234567890123451167 1112 const char *s = "+23456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 1168 1113 … … 1245 1190 } 1246 1191 1247 // Rappel des inline functions pour commentaires 1248 //++ 1249 // inline float XMin() 1250 // Retourne l'abscisse minimum. 1251 //-- 1252 //++ 1253 // inline float XMax() 1254 // Retourne l'abscisse maximum. 1255 //-- 1256 //++ 1257 // inline float YMin() 1258 // Retourne l'ordonnee minimum. 1259 //-- 1260 //++ 1261 // inline float YMax() 1262 // Retourne l'ordonnee maximum. 1263 //-- 1264 //++ 1265 // inline int NBinX() 1266 // Retourne le nombre de bins selon X. 1267 //-- 1268 //++ 1269 // inline int NBinY() 1270 // Retourne le nombre de bins selon Y. 1271 //-- 1272 //++ 1273 // inline float WBinX() 1274 // Retourne la largeur du bin selon X. 1275 //-- 1276 //++ 1277 // inline float WBinY() 1278 // Retourne la largeur du bin selon Y. 1279 //-- 1280 //++ 1281 // inline float* Bins() const 1282 // Retourne le pointeur sur le tableaux des contenus. 1283 //-- 1284 //++ 1285 // inline float operator()(int i,int j) const 1286 // Retourne le contenu du bin i,j. 1287 //-- 1288 //++ 1289 // inline float& operator()(int i,int j) 1290 // Remplit le contenu du bin i,j. 1291 //-- 1292 //++ 1293 // inline float Error(int i,int j) const 1294 // Retourne l'erreur du bin i,j. 1295 //-- 1296 //++ 1297 // inline double Error2(int i,int j) const 1298 // Retourne l'erreur au carre du bin i,j. 1299 //-- 1300 //++ 1301 // inline double& Error2(int i,int j) 1302 // Remplit l'erreur au carre du bin i,j. 1303 //-- 1304 //++ 1305 // inline float NData() const 1306 // Retourne la somme ponderee. 1307 //-- 1308 //++ 1309 // inline int NEntries() const 1310 // Retourne le nombre d'entrees. 1311 //-- 1312 //++ 1313 // inline void BinLowEdge(int i,int j,float& x,float& y) 1314 // Retourne l'abscisse et l'ordonnee du coin inferieur du bin i,j. 1315 //-- 1316 //++ 1317 // inline void BinCenter(int i,int j,float& x,float& y) 1318 // Retourne l'abscisse et l'ordonnee du centre du bin i,j. 1319 //-- 1320 //++ 1321 // inline void BinHighEdge(int i,int j,float& x,float& y) 1322 // Retourne l'abscisse et l'ordonnee du coin superieur du bin i,j. 1323 //-- 1324 //++ 1325 // inline void FindBin(float x,float y,int& i,int& j) 1326 // Retourne les numeros du bin contenant l'abscisse et l'ordonnee x,y. 1327 //-- 1328 1329 /////////////////////////////////////////////////////////////////// 1330 //++ 1192 /////////////////////////////////////////////////////////////////// 1331 1193 // Titre Methodes pour gerer les projections 1332 //-- 1333 1334 //++ 1194 1195 /*! 1196 Pour creer la projection X. 1197 */ 1335 1198 void Histo2D::SetProjX() 1336 //1337 // Pour creer la projection X.1338 //--1339 1199 { 1340 1200 if( hprojx != NULL ) DelProjX(); … … 1343 1203 } 1344 1204 1345 //++ 1205 /*! 1206 Pour creer la projection Y. 1207 */ 1346 1208 void Histo2D::SetProjY() 1347 //1348 // Pour creer la projection Y.1349 //--1350 1209 { 1351 1210 if( hprojy != NULL ) DelProjY(); … … 1354 1213 } 1355 1214 1356 //++ 1215 /*! 1216 Pour creer les projections X et Y. 1217 */ 1357 1218 void Histo2D::SetProj() 1358 //1359 // Pour creer les projections X et Y.1360 //--1361 1219 { 1362 1220 SetProjX(); … … 1364 1222 } 1365 1223 1366 //++ 1224 /*! 1225 Informations sur les projections. 1226 */ 1367 1227 void Histo2D::ShowProj() 1368 //1369 // Informations sur les projections.1370 //--1371 1228 { 1372 1229 if( hprojx != NULL ) cout << ">>>> Projection X set : "<< hprojx <<endl; … … 1376 1233 } 1377 1234 1378 //++ 1235 /*! 1236 Destruction de l'histogramme de la projection selon X. 1237 */ 1379 1238 void Histo2D::DelProjX() 1380 //1381 // Destruction de l'histogramme de la projection selon X.1382 //--1383 1239 { 1384 1240 if( hprojx == NULL ) return; … … 1387 1243 } 1388 1244 1389 //++ 1245 /*! 1246 Destruction de l'histogramme de la projection selon X. 1247 */ 1390 1248 void Histo2D::DelProjY() 1391 //1392 // Destruction de l'histogramme de la projection selon X.1393 //--1394 1249 { 1395 1250 if( hprojy == NULL ) return; … … 1398 1253 } 1399 1254 1400 //++ 1255 /*! 1256 Destruction des histogrammes des projections selon X et Y. 1257 */ 1401 1258 void Histo2D::DelProj() 1402 //1403 // Destruction des histogrammes des projections selon X et Y.1404 //--1405 1259 { 1406 1260 DelProjX(); … … 1408 1262 } 1409 1263 1410 //++ 1264 /*! 1265 Remise a zero de la projection selon X. 1266 */ 1411 1267 void Histo2D::ZeroProjX() 1412 //1413 // Remise a zero de la projection selon X.1414 //--1415 1268 { 1416 1269 if( hprojx == NULL ) return; … … 1418 1271 } 1419 1272 1420 //++ 1273 /*! 1274 Remise a zero de la projection selon Y. 1275 */ 1421 1276 void Histo2D::ZeroProjY() 1422 //1423 // Remise a zero de la projection selon Y.1424 //--1425 1277 { 1426 1278 if( hprojy == NULL ) return; … … 1428 1280 } 1429 1281 1430 //++ 1282 /*! 1283 Remise a zero des projections selon X et Y. 1284 */ 1431 1285 void Histo2D::ZeroProj() 1432 //1433 // Remise a zero des projections selon X et Y.1434 //--1435 1286 { 1436 1287 ZeroProjX(); … … 1438 1289 } 1439 1290 1440 // Rappel des inline functions pour commentaires 1441 //++ 1442 // inline Histo* HProjX() 1443 // Retourne le pointeur sur l'histo 1D de la projection selon X. 1444 //-- 1445 //++ 1446 // inline Histo* HProjY() 1447 // Retourne le pointeur sur l'histo 1D de la projection selon Y. 1448 //-- 1449 1450 /////////////////////////////////////////////////////////////////// 1451 //++ 1291 /////////////////////////////////////////////////////////////////// 1452 1292 // Titre Methodes pour gerer les bandes 1453 //-- 1454 1455 //++ 1293 1294 /*! 1295 Pour creer une bande en X entre ybmin et ybmax. 1296 */ 1456 1297 int Histo2D::SetBandX(float ybmin,float ybmax) 1457 //1458 // Pour creer une bande en X entre ybmin et ybmax.1459 //--1460 1298 { 1461 1299 b_s.num = lbandx.size(); … … 1468 1306 } 1469 1307 1470 //++ 1308 /*! 1309 Pour creer une bande en Y entre xbmin et xbmax. 1310 */ 1471 1311 int Histo2D::SetBandY(float xbmin,float xbmax) 1472 //1473 // Pour creer une bande en Y entre xbmin et xbmax.1474 //--1475 1312 { 1476 1313 b_s.num = lbandy.size(); … … 1483 1320 } 1484 1321 1485 //++ 1322 /*! 1323 Destruction des histogrammes des bandes selon X. 1324 */ 1486 1325 void Histo2D::DelBandX() 1487 //1488 // Destruction des histogrammes des bandes selon X.1489 //--1490 1326 { 1491 1327 if( lbandx.size() <= 0 ) return; … … 1495 1331 } 1496 1332 1497 //++ 1333 /*! 1334 Destruction des histogrammes des bandes selon Y. 1335 */ 1498 1336 void Histo2D::DelBandY() 1499 //1500 // Destruction des histogrammes des bandes selon Y.1501 //--1502 1337 { 1503 1338 if( lbandy.size() <= 0 ) return; … … 1507 1342 } 1508 1343 1509 //++ 1344 /*! 1345 Remise a zero des bandes selon X. 1346 */ 1510 1347 void Histo2D::ZeroBandX() 1511 //1512 // Remise a zero des bandes selon X.1513 //--1514 1348 { 1515 1349 if( lbandx.size() <= 0 ) return; … … 1519 1353 } 1520 1354 1521 //++ 1355 /*! 1356 Remise a zero des bandes selon Y. 1357 */ 1522 1358 void Histo2D::ZeroBandY() 1523 //1524 // Remise a zero des bandes selon Y.1525 //--1526 1359 { 1527 1360 if( lbandy.size() <= 0 ) return; … … 1531 1364 } 1532 1365 1533 //++ 1366 /*! 1367 Retourne un pointeur sur la bande numero `n' selon X. 1368 */ 1534 1369 Histo* Histo2D::HBandX(int n) const 1535 //1536 // Retourne un pointeur sur la bande numero `n' selon X.1537 //--1538 1370 { 1539 1371 if( lbandx.size() <= 0 || n < 0 || n >= (int) lbandx.size() ) return NULL; … … 1543 1375 } 1544 1376 1545 //++ 1377 /*! 1378 Retourne un pointeur sur la bande numero `n' selon Y. 1379 */ 1546 1380 Histo* Histo2D::HBandY(int n) const 1547 //1548 // Retourne un pointeur sur la bande numero `n' selon Y.1549 //--1550 1381 { 1551 1382 if( lbandy.size() <= 0 || n < 0 || n >= (int) lbandy.size() ) return NULL; … … 1555 1386 } 1556 1387 1557 //++ 1388 /*! 1389 Retourne les limites de la bande numero `n' selon X. 1390 */ 1558 1391 void Histo2D::GetBandX(int n,float& ybmin,float& ybmax) const 1559 //1560 // Retourne les limites de la bande numero `n' selon X.1561 //--1562 1392 { 1563 1393 ybmin = 0.; ybmax = 0.; … … 1568 1398 } 1569 1399 1570 //++ 1400 /*! 1401 Retourne les limites de la bande numero `n' selon Y. 1402 */ 1571 1403 void Histo2D::GetBandY(int n,float& xbmin,float& xbmax) const 1572 //1573 // Retourne les limites de la bande numero `n' selon Y.1574 //--1575 1404 { 1576 1405 xbmin = 0.; xbmax = 0.; … … 1581 1410 } 1582 1411 1583 //++ 1412 /*! 1413 Informations sur les bandes. 1414 */ 1584 1415 void Histo2D::ShowBand(int lp) 1585 //1586 // Informations sur les bandes.1587 //--1588 1416 { 1589 1417 cout << ">>>> Nombre de bande X : " << lbandx.size() << endl; … … 1608 1436 } 1609 1437 1610 // Rappel des inline functions pour commentaires 1611 //++ 1612 // inline int NBandX() 1613 // Retourne le nombre de bandes selon X 1614 //-- 1615 //++ 1616 // inline int NBandY() 1617 // Retourne le nombre de bandes selon Y 1618 //-- 1619 1620 /////////////////////////////////////////////////////////////////// 1621 //++ 1622 // Titre Methodes pour gerer les bandes equidistantes 1623 //-- 1624 1625 //++ 1438 /////////////////////////////////////////////////////////////////// 1439 // Titre Methodes pour gerer les bandes equidistantes ou slices 1440 1441 /*! 1442 Pour creer `nsli' bandes equidistantes selon X. 1443 */ 1626 1444 int Histo2D::SetSliX(int nsli) 1627 //1628 // Pour creer `nsli' bandes equidistantes selon X.1629 //--1630 1445 { 1631 1446 if( nsli <= 0 ) return -1; … … 1645 1460 } 1646 1461 1647 //++ 1462 /*! 1463 Pour creer `nsli' bandes equidistantes selon Y. 1464 */ 1648 1465 int Histo2D::SetSliY(int nsli) 1649 //1650 // Pour creer `nsli' bandes equidistantes selon Y.1651 //--1652 1466 { 1653 1467 if( nsli <= 0 ) return -1; … … 1667 1481 } 1668 1482 1669 //++ 1483 /*! 1484 Destruction des bandes equidistantes selon X. 1485 */ 1670 1486 void Histo2D::DelSliX() 1671 //1672 // Destruction des bandes equidistantes selon X.1673 //--1674 1487 { 1675 1488 if( lslix.size() <= 0 ) return; … … 1679 1492 } 1680 1493 1681 //++ 1494 /*! 1495 Destruction des bandes equidistantes selon Y. 1496 */ 1682 1497 void Histo2D::DelSliY() 1683 //1684 // Destruction des bandes equidistantes selon Y.1685 //--1686 1498 { 1687 1499 if( lsliy.size() <= 0 ) return; … … 1691 1503 } 1692 1504 1693 //++ 1505 /*! 1506 Remise a zero des bandes equidistantes selon X. 1507 */ 1694 1508 void Histo2D::ZeroSliX() 1695 //1696 // Remise a zero des bandes equidistantes selon X.1697 //--1698 1509 { 1699 1510 if( lslix.size() <= 0 ) return; … … 1703 1514 } 1704 1515 1705 //++ 1516 /*! 1517 Remise a zero des bandes equidistantes selon Y. 1518 */ 1706 1519 void Histo2D::ZeroSliY() 1707 //1708 // Remise a zero des bandes equidistantes selon Y.1709 //--1710 1520 { 1711 1521 if( lsliy.size() <= 0 ) return; … … 1715 1525 } 1716 1526 1717 //++ 1527 /*! 1528 Retourne un pointeur sur la bande equidistante numero `n' 1529 selon X. 1530 */ 1718 1531 Histo* Histo2D::HSliX(int n) const 1719 //1720 // Retourne un pointeur sur la bande equidistante numero `n'1721 // selon X.1722 //--1723 1532 { 1724 1533 if( lslix.size() <= 0 || n < 0 || n >= (int) lslix.size() ) return NULL; … … 1728 1537 } 1729 1538 1730 //++ 1539 /*! 1540 Retourne un pointeur sur la bande equidistante numero `n' 1541 selon Y. 1542 */ 1731 1543 Histo* Histo2D::HSliY(int n) const 1732 //1733 // Retourne un pointeur sur la bande equidistante numero `n'1734 // selon Y.1735 //--1736 1544 { 1737 1545 if( lsliy.size() <= 0 || n < 0 || n >= (int) lsliy.size() ) return NULL; … … 1741 1549 } 1742 1550 1743 //++ 1551 /*! 1552 Informations sur les bandes equidistantes. 1553 */ 1744 1554 void Histo2D::ShowSli(int lp) 1745 //1746 // Informations sur les bandes equidistantes.1747 //--1748 1555 { 1749 1556 list<bande_slice>::iterator i; … … 1764 1571 } 1765 1572 } 1766 1767 // Rappel des inline functions pour commentaires1768 //++1769 // inline int NSliX()1770 // Retourne le nombre de slices selon X1771 //--1772 //++1773 // inline int NSliY()1774 // Retourne le nombre de slices selon Y1775 //--1776 1777 1573 1778 1574 ///////////////////////////////////////////////////////////
Note:
See TracChangeset
for help on using the changeset viewer.
