KVIDGrid.h

Go to the documentation of this file.

/***************************************************************************
                          KVIDGrid.h  -  description
                             -------------------
    begin                : Nov 10 2004
    copyright            : (C) 2004 by J.D. Frankland
    email                : frankland@ganil.fr
 
$Id: KVIDGrid.h,v 1.51 2009/04/03 14:30:27 franklan Exp $
***************************************************************************/
 
#ifndef KVIDGrid_H
#define KVIDGrid_H
 
#include "KVIDGraph.h"
#include "KVIDLine.h"
#include "Riostream.h"
#include "TObjArray.h"
#include <TPad.h>
#include "TGWindow.h"
#include "TF1.h"
#include "TClass.h"
#include "TMath.h"
 
class KVIDGrid : public KVIDGraph {
 
    mutable TObjArray fEmbracingLines;
 
protected:
 
   void init();
   void ReadIdentifierFromAsciiFile(TString& name, TString& type, TString& cl, std::ifstream& gridfile);
 
public:
 
   KVIDGrid();
   virtual ~ KVIDGrid();
 
   KVIDLine* NewLine(const Char_t* idline_class = "");
   Int_t GetIDLinesEmbracingPoint(const Char_t* direction, Double_t x, Double_t y) const;
 
   KVIDLine* FindNearestIDLineFast(Double_t x, Double_t y, const Char_t* position,
                                   Int_t& idx, Int_t& idx_min, Int_t& idx_max, Double_t& dist, Double_t& dist_min, Double_t& dist_max) const
   {
 
      Int_t nlines = GetNumberOfIdentifiers();
      idx_min = 0;                 //minimum index
      idx_max = nlines - 1;        // maximum index
      idx = idx_max / 2;     //current index i.e. we begin in the middle
      dist = dist_min = dist_max = -1.;
 
      while (idx_max > idx_min + 1) {
 
         KVIDLine* line = (KVIDLine*)GetIdentifierAt(idx);
         Bool_t point_above_line = line->WhereAmI(x, y, position);
 
         if (point_above_line) {
            idx_min = idx;
            idx += (Int_t)((idx_max - idx) / 2 + 0.5);
         }
         else {
            idx_max = idx;
            idx -= (Int_t)((idx - idx_min) / 2 + 0.5);
         }
      }
      KVIDLine* upper = (KVIDLine*)GetIdentifierAt(idx_max);
      KVIDLine* lower = (KVIDLine*)GetIdentifierAt(idx_min);
      Int_t dummy = 0;
      dist_max = TMath::Abs(upper->DistanceToLine(x, y, dummy));
      dist_min = TMath::Abs(lower->DistanceToLine(x, y, dummy));
      if (dist_max < dist_min) {
         dist = dist_max;
         idx = idx_max;
         return upper;
      }
      dist = dist_min;
      idx = idx_min;
      return lower;
   }
 
   KVIDLine* FindNearestEmbracingIDLine(Double_t x, Double_t y, const Char_t* position, const Char_t* axis,
                                        Int_t& idx, Int_t& idx_min, Int_t& idx_max, Double_t& dist, Double_t& dist_min, Double_t& dist_max) const
   {
 
      Int_t nlines = GetIDLinesEmbracingPoint(axis, x, y);
      if (!nlines) return 0;   // no lines
      idx_min = 0;                 //minimum index
      idx_max = nlines - 1;        // maximum index
      idx = idx_max / 2;     //current index i.e. we begin in the middle
      dist = dist_min = dist_max = -1.;
 
      while (idx_max > idx_min + 1) {
 
         KVIDLine* line = (KVIDLine*)fEmbracingLines.UncheckedAt(idx);
         Bool_t point_above_line = line->WhereAmI(x, y, position);
 
         if (point_above_line) {
            idx_min = idx;
            idx += (Int_t)((idx_max - idx) / 2 + 0.5);
         }
         else {
            idx_max = idx;
            idx -= (Int_t)((idx - idx_min) / 2 + 0.5);
         }
      }
      KVIDLine* upper = (KVIDLine*)fEmbracingLines.UncheckedAt(idx_max);
      KVIDLine* lower = (KVIDLine*)fEmbracingLines.UncheckedAt(idx_min);
      Int_t dummy = 0;
      if (idx_max == nlines - 1) {
         if (upper->WhereAmI(x, y, position)) {
            idx = idx_min = fIdentifiers->IndexOf(upper); // index of last line
            idx_max = -1;
            dist = dist_min = TMath::Abs(upper->DistanceToLine(x, y, dummy));
            return upper;
         }
      }
      if (idx_min == 0) {
         if (!lower->WhereAmI(x, y, position)) {
            idx_min = -1;
            idx = idx_max = fIdentifiers->IndexOf(lower); // index of first line
            dist = dist_max = TMath::Abs(lower->DistanceToLine(x, y, dummy));
            return lower;
         }
      }
 
      dist_max = TMath::Abs(upper->DistanceToLine(x, y, dummy));
      dist_min = TMath::Abs(lower->DistanceToLine(x, y, dummy));
      idx_min = fIdentifiers->IndexOf(lower);
      idx_max = fIdentifiers->IndexOf(upper);
      if (dist_max < dist_min) {
         dist = dist_max;
         idx = idx_max;
         return upper;
      }
      dist = dist_min;
      idx = idx_min;
      return lower;
   }
 
   KVIDLine* FindNextEmbracingLine(Int_t& index, Int_t inc_index, Double_t x, Double_t y, const Char_t* axis) const
   {
 
      Int_t ii = index + inc_index;
      Int_t nlines = GetNumberOfIdentifiers();
      KVIDLine* l = 0;
      while ((ii > -1 && ii < nlines)) {
         l = (KVIDLine*)GetIdentifierAt(ii);
         if (l->IsBetweenEndPoints(x, y, axis)) break;
         ii += inc_index;
      }
      if (ii < 0 || ii >= nlines) {
         index = -1;
         return 0;
      }
      index = ii;
      return l;
   }
 
 
   void Initialize();
 
   virtual void CalculateLineWidths() {}
 
   virtual TClass* DefaultIDLineClass()
   {
      return TClass::GetClass("KVIDLine");
   }
   virtual TClass* DefaultOKLineClass()
   {
      return TClass::GetClass("KVIDLine");
   }
 
 
   ClassDef(KVIDGrid, 5)        //Base class for 2D identification grids
};
 
#endif