ObjectStock.cxx

Go to the documentation of this file.

#include "ObjectStock.h"

#include <iostream>
#include <TPad.h>
#include <TLine.h>
#include <TBox.h>
#include <TPolyLine.h>

#include "ListObjectStock.h"
#include "THStock.h"
#include "../CommonXAxis.h"

//for ROOT dicionnary
ClassImp ( CandleStock )
ClassImp ( BarStock )
ClassImp ( PStockLine )
ClassImp ( CollectionObjectStock )



std::vector<float> CandleStock::GetValues() const
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry CandleStock::GetValues()" << std::endl;
#endif
  std::vector<float> values;
  values.push_back( fopen ); values.push_back( fhigh ); values.push_back( flow ); values.push_back( fclose );
  return values;
}

std::vector<std::string> CandleStock::MakeStringForStatusBar( int /*px*/, int /*py*/) const
{
/* called when mouse moves
#ifdef DEBUG_OBJSTOCK
        std::cout << "CandleStock::MakeStringForStatusBar " << std::endl;
#endif
*/
        std::vector < std::string > vec_str_text;
        std::string text_str0, text_str1, indic_str;
        std::vector<float> values;
        time_t date;

        values = GetValues();
        indic_str = GetNameObject();
        text_str1 = indic_str + " open="+ Utils::toString<float>(values[0]) + " high="+ Utils::toString<float>(values[1])+
                  " low="+Utils::toString<float>(values[2])+" close="+ Utils::toString<float>(values[3]);
        date = GetDate();
        text_str0 = Utils::Time_tToString( date );

        vec_str_text.push_back( text_str0 );
        vec_str_text.push_back( text_str1 );
        return vec_str_text;
}


//bin and opt never used, only for polymorphisme
void CandleStock::SetValues( unsigned int /*bin*/, std::vector<double> values, double xmin, double xmax, time_t date, unsigned int /*opt_value*/ )
{
/*
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry CandleStock::SetValues" << std::endl;
  std::cout << "size values " << values.size() << std::endl;
#endif
*/
  fxmin = xmin;
  fxmax = xmax;
  fopen = values[0]; fhigh = values[1]; flow = values[2]; fclose = values[3];
  //add update of date, may do better...
  fdate = date;
}

/*
void CandleStock::ClearObject()
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "CandleStock::ClearObject " << std::endl;
#endif
}
*/

void CandleStock::GetExtrema( double & min, double & max ) const
{
/*
#ifdef DEBUG_OBJSTOCK
    std::cout << "entry CandleStock::GetExtrema " << std::endl;
#endif
*/
    std::vector<float> values;
    values = GetValues();

    // extract high and low
    max = values[1];
    min = values[2];
}

// to rewrite, look at THistPainter Stock
int CandleStock::DistancetoPrimitive(int px, int py, AbstractObjectStock** /*obj*/ ) //const
{
/*
#ifdef DEBUG_OBJSTOCK
    std::cout << "Entry CandleStock::DistancetoPrimitive " << std::endl;
#endif
*/
  //std::cout << "CandleStock::DistancetoPrimitive " << std::endl;
  Int_t pxl, pyl, pxt, pyt;

  Int_t px1 = gPad->XtoAbsPixel(fxmin);
  Int_t py1 = gPad->YtoAbsPixel(fopen);
  Int_t px2 = gPad->XtoAbsPixel(fxmax);
  Int_t py2 = gPad->YtoAbsPixel(fclose);

  //std::cout << px1 << " " << py1 << " " << px2 << " " << py2 << std::endl;
  //std::cout << px << " " << py << std::endl;

  //not necessary here flow shoud be < fhigh !!
  if (px1 < px2) {pxl = px1; pxt = px2;}
  else           {pxl = px2; pxt = px1;}
  if (py1 < py2) {pyl = py1; pyt = py2;}
  else           {pyl = py2; pyt = py1;}

  // Are we inside the box?
  if ( (px >= pxl && px <= pxt) && (py >= pyl && py <= pyt) ) {
      //std::cout << " return 0 " << std::endl;
      return 0;
  }
  //test delete other test later;
  else return 9999;

  //         // }
  // Inside enought ?? maybe not, extend for more, picked point...
  // never executed after, need to find closer

  // test not necessary normally, to check

  /* make return 9999 in other case
  Int_t dxl = TMath::Abs(px - pxl);
  // ???
  if (py < pyl) dxl += pyl - py; if (py > pyt) dxl += py - pyt;
  Int_t dxt = TMath::Abs(px - pxt);
  if (py < pyl) dxt += pyl - py; if (py > pyt) dxt += py - pyt;
  Int_t dyl = TMath::Abs(py - pyl);
  if (px < pxl) dyl += pxl - px; if (px > pxt) dyl += px - pxt;
  Int_t dyt = TMath::Abs(py - pyt);
  if (px < pxl) dyt += pxl - px; if (px > pxt) dyt += px - pxt;

  Int_t distance = dxl;
  if (dxt < distance) distance = dxt;
  if (dyl < distance) distance = dyl;
  if (dyt < distance) distance = dyt;

  //return distance - Int_t(0.5*fLineWidth);
  //std::cout << "distance " << distance << std::endl;
  return distance; // - Int_t(1);
  */
}


int CandleStock::DistancetoPoint( int /*px*/, int py, double & yvalue, int /*bin*/ ) const
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry CandleStock::distancetoPoint " << std::endl;
#endif
  int dist = 9999;
  int distance;
  double dtab_py[4] = { fopen, fclose, fhigh, flow };

  for ( unsigned int y = 0; y<4; y++ )  {
      //distance = TMath::Abs( value_y - dtab_py[y] );
      distance = TMath::Abs( py - gPad->YtoAbsPixel( dtab_py[y] ));
      if ( distance < dist ) {
          //std::cout << "min dist tab_py[y] " << tab_py[y] << " min distance " <<  distance << std::endl;
          dist = distance;
          //assign the correct value
          yvalue = dtab_py[y];
      }
  }
  std::cout << "Exit CandleStock::distancetoPoint dist py " << dist << " " << yvalue << std::endl;
  return dist;
}


void CandleStock::Paint( const Option_t* )
{
  //std::cout << "Entry Paint CandleStock " << std::endl;
  TBox box;
  TLine line;
  //recompute on the fly
  Double_t xmiddle = ( fxmin + fxmax ) / 2.;

  // test on kPaint done in ListDataStock
  if ( fclose >= fopen ) {
      box.SetFillColor(3); //green
      line.SetLineColor(3);
  }
  else {
      box.SetFillColor(2); //red
      line.SetLineColor(2);
  }
  //std::cout << fxmin << " " << fopen << " " << fxmax << " " << fclose << std::endl;
  //std::cout << xmiddle << " " << flow << " " << fhigh << " " << std::endl;
  box.PaintBox ( fxmin, fopen, fxmax, fclose );
  line.PaintLine ( xmiddle, flow, xmiddle, fhigh );
}


//all constructor to move into class def
BarStock::BarStock () : AbstractObjectStock () {
  //std::cout << "Constructor BarStock default" << std::endl;
  fdate = 0;  fvalue = 0;
  fref0_value = false;
  fxmax = fxmin = 0;
}

//could extend with option, will be more general
BarStock::BarStock ( bool ref0 ) : AbstractObjectStock () {
  //std::cout << "Constructor BarStock with ref0 " << ref0 << std::endl;
  fdate = 0;  fvalue = 0;
  fxmin = fxmax = 0;
  fref0_value = ref0;
}

//ref0 default 0
/*
BarStock::BarStock ( const char * name, bool ref0 ) : AbstractObjectStock(){
  //std::cout << "Constructor BarStock with name and ref0 " << ref0 <<std::endl;
  //std::cout << "name " << name << " name_str " << name_str << std::endl;
  fref0_value = ref0;
}
*/
std::vector<float> BarStock::GetValues() const
{
  //std::cout << "Entry CandleStock::GetValues()" << std::endl;
  std::vector<float> values;
  values.push_back( fvalue );
  return values;
}

std::vector<std::string> BarStock::MakeStringForStatusBar( int /*px*/, int /*py*/ ) const
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "BarStock::MakeStringForStatusBar " << std::endl;
#endif
    std::vector < std::string > vec_str_text;
    std::string text_str0, text_str1, indic_str;
    std::vector<float> values;
    time_t date;

    values = GetValues();
    indic_str = GetNameObject();
    text_str1 = indic_str + " ="+ Utils::toString<float>(values[0]);
    date = GetDate();
    text_str0 = Utils::Time_tToString( date );

    vec_str_text.push_back( text_str0 );
    vec_str_text.push_back( text_str1 );
    return vec_str_text;
}

void BarStock::GetExtrema( double & min, double & max ) const
{
/*
#ifdef DEBUG_OBJSTOCK
    std::cout << " Entry BarStock::GetExtrema " << std::endl;
#endif
*/
    std::vector<float> values;
    values = GetValues();
    //std::cout << "values[0] " << values[0] << " " << values[1] << std::endl;
    max = values[0];
    min = values[0];
}

//default opt_value= 0
void BarStock::SetValues( unsigned int /*bin*/, std::vector<double> values,
     double xmin, double xmax, time_t date, unsigned int opt_value )
{
/*
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry BarStock::SetValues" << std::endl;
  //std::cout << "size values " << values.size() << std::endl;
  //std::cout << "values[opt_value ] " << opt_value << " " << values[opt_value] << std::endl;
#endif
*/

  fvalue = (Double_t) values[opt_value];
  fxmin = xmin;
  fxmax = xmax;
  fdate = date;
}

int BarStock::DistancetoPrimitive(int px, int py, AbstractObjectStock** /*obj*/ ) //const
{
/*
#ifdef DEBUG_OBJSTOCK
  std::cout << "BarStock::DistancetoPrimitive" << std::endl;
  std::cout << "px " << px << " py " << py << std::endl;
#endif
*/
  Int_t pxl, pyl, pxt, pyt;
  Int_t py1;

  Int_t px1 = gPad->XtoAbsPixel(fxmin);

  //strange work for both, in fact 0. in both case,
  //because Yymin and ymax in THistPainterStock certainly ?? to understand
  /*
  if ( fref0_value ) {
      py1 = gPad->YtoAbsPixel(0.);
      std::cout << "use fref0 " << py1 << std::endl;
  } else {
      py1 = gPad->YtoAbsPixel(0.); //original
  }*/

  py1 = gPad->YtoAbsPixel(0.);
  //Int_t py1 = gPad->YtoAbsPixel( fvalue_min ); //keep 0 difficult to get small value with gPad, TFrame min.Hparam..??
                                               //or force to 0. easier certainly and better
  Int_t px2 = gPad->XtoAbsPixel( fxmax );
  Int_t py2 = gPad->YtoAbsPixel( fvalue );
  /*
  std::cout << " fvalues " << fvalue << std::endl;
  std::cout << "px1 " << px1 << " px2 " << px2 << std::endl;
  std::cout << "py1 " << py1 << " py2 " << py2 << std::endl;
  */

  //should not be necessary, consider all positive ?? problem ??
  //necessary if fref0_value is true
  if (px1 < px2) {pxl = px1; pxt = px2;}
  else           {pxl = px2; pxt = px1;}
  if (py1 < py2) {pyl = py1; pyt = py2;}
  else           {pyl = py2; pyt = py1;}
  //std::cout << "py " << py << " pyl " << pyl << " pyt " << pyt << std::endl;

  // Are we inside the box?
  //   // if (GetFillStyle()) {
  if ( (px >= pxl && px <= pxt) && (py >= pyl && py <= pyt) ) {
      //std::cout << "py " << py << " pyl " << pyl << " pyt " << pyt << std::endl;
      std::cout << " BarStock::DtP return 0 " << std::endl;
      return 0;
  }
  //std::cout << "BarStock return 9999 " << std::endl;
  return 9999;
}

int BarStock::DistancetoPoint(Int_t /*px*/, Int_t py, Double_t &yvalue, int /*bin*/) const
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry Bar::DistancetoPoint " << std::endl;
  std::cout << "py " << py << std::endl;
#endif

 yvalue = fvalue;
 return TMath::Abs ( py - gPad->YtoAbsPixel(fvalue) );
}

// all paint could be const
void BarStock::Paint( const Option_t* /*option*/ )
{
  //std::cout << "BarStock::Paint option ref " << fref0_value << std::endl;//option << std::endl;
  Double_t ymin;
  //default fvalue, modified internally if needed, not the member fvalue !!
  Double_t fvalue2 = fvalue;

  if ( fref0_value ) {
      ymin = 0.;
      //std::cout << "use fref0 " << ymin << std::endl;
  } else {
      //std::cout << "use original " << std::endl;
      ymin = gPad->GetUymin(); //original use min of the pad
  }

  //should checked ymin and fvalue if ref0
  if ( ymin > fvalue ) {
      Double_t tmp = ymin;
      ymin = fvalue;
      fvalue2 = tmp; // ==ymin and do not erase member fvalue
  }
  TBox box;
  box.SetFillColor(2); //red
  box.PaintBox ( fxmin, ymin, fxmax, fvalue2 );
}



//no need indic name will be set by Factory or Collection
// do not need indic, just a name, deal name and properties by calling function (Factory or Collection)
// even size is not needed, should be resized before drawing
PStockLine::PStockLine( UInt_t size ) : IndicatorObjectStock()
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry Constructor PStockLine size " << size << std::endl;
#endif

  plvalues.reserve( size );
  fx.reserve ( size );
  //std::cout << "fx.size() " << fx.size() << std::endl;
  for ( UInt_t i = 0; i < size; i++ ) {
      fx.push_back (0.);
      plvalues.push_back (0.);
  }
}

PStockLine::PStockLine( std::string name, unsigned int size ) : IndicatorObjectStock( name )
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry Constructor PStockLine size " << size << std::endl;
#endif

  plvalues.reserve( size );
  fx.reserve ( size );
  //std::cout << "fx.size() " << fx.size() << std::endl;
  for ( UInt_t i = 0; i < size; i++ ) {
      fx.push_back (0.);
      plvalues.push_back (0.);
  }
}

float PStockLine::ExtrapolateYPad ( int px, int bin0, int bin1, float y0, float y1 ) const
{
  //std::cout << "Entry PStockLine::ExtrapolateYPad " << std::endl;
  //need coeff and origin
  float coeff, origin, extra_y;

  //get x value in Pad coordinate
  float x0 = fParentTHStock->GetXPadFromBin ( bin0 );
  float x1 = fParentTHStock->GetXPadFromBin ( bin1 );
  //compute temporary coeff and origin
  coeff = ( y1 - y0 ) / ( x1 - x0 );
  origin = y0 - coeff * x0;
  //std::cout << "coeff " << coeff << "  origin " << origin << std::endl;
  //extrapolate to px
  extra_y = coeff * gPad->AbsPixeltoX( px ) + origin;
  //std::cout << "extrapolateY Pstock " << extra_y << std::endl;
  return extra_y;
}

std::vector<float> PStockLine::GetValues( int px, int py, time_t & date ) const
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry PStockLine::GetValues px/py, &date " << px << " " << py << std::endl;
  //std::cout << " fParentTHStock " << fParentTHStock << std::endl;
#endif

  std::vector<float> values;
  Int_t bin;
  //option for extrapolating, considered if > 0, cannot use reference and default, test pointer * ??
  Int_t bin2 = 1;

  // why 2 bins ??
  //bin send as reference
  bin = fParentTHStock->GetBinFromPixel(px, bin2);
  std::cout << "date " << date << " bin " << bin << " bin2 " << bin2 << std::endl;

  // recompute shift
  int shift_futur = fParentTHStock->GetCommonXAxis()->GetShift();
  //std::cout << "shift_futur " << shift_futur << std::endl;
  // correct calculation of shift_left by the shift_futur of the axis
  int shift_left = fParentTHStock->GetCommonXAxis()->GetNbins() - shift_futur - plvalues.size();
  //std::cout << "shift_left " << shift_left << std::endl;
  //std::cout << "size - ( bin - shift_left )" <<  plvalues.size() - ( bin -shift_left ) << std::endl;
  //std::cout << "shift axis " << fParentTHStock->GetCommonXAxis()->GetShift()  << std::endl;

  //get value at bin, and closer bin
  float value_pt0 = plvalues[ plvalues.size() - ( bin  - shift_left ) ];
  float value_pt1 = plvalues[ plvalues.size() - ( bin2 - shift_left ) ];
  //std::cout << "date " << dates[ plvalues.size() - ( bin  - shift_left ) ] << std::endl;
  //now uses store vector<dates>
  date = dates[ plvalues.size() - ( bin  - shift_left ) ];

  //Extrapolate, need function ?? if reused later yes !!
  float value_pt = ExtrapolateYPad ( px, bin, bin2, value_pt0, value_pt1 );
  //std::cout << "return extrapolate " << value_pt << std::endl;

  values.push_back ( value_pt );
  return values;
}


std::vector<std::string> PStockLine::MakeStringForStatusBar( int px, int py ) const
{

#ifdef DEBUG_OBJSTOCK
        std::cout << " PStockLine::MakeStringForStatusBar " << std::endl;
        std::cout << " px, py" << px << " " << py << std::endl;
        std::cout << "Name " << GetNameObject() << std::endl;
#endif

        std::string text_str0, text_str1;
        std::vector<std::string> vec_string;
        time_t date;
        std::vector<float> values;

        values = GetValues( px, py, date );
        //assign the date
        text_str0 = Utils::Time_tToString( date, true );
        //assign the unique value
        text_str1 =  GetNameObject() + " = " + Utils::toString<float>( values[0] );

        vec_string.push_back( text_str0 );
        vec_string.push_back( text_str1 );
        //std::cout << " return from PStockLine::MakeStringForStatusBar text " << text_str0 << " " << text_str1 << std::endl;
        return vec_string;
}

void PStockLine::GetExtrema( double & min, double & max ) const
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "\n\tPStockLine::GetExtrema size plvalues " << plvalues.size() << std::endl;
#endif
    std::vector<Double_t>::const_iterator it, it2;
    it2 = plvalues.end();
    Double_t value, value_min, value_max;
    value_min = 10.0e6;
    value_max = 0.;

    for ( it = plvalues.begin(); it != it2; ++it  ) {
        value = (*it);

        if ( value < value_min ) value_min = value;
        if ( value > value_max ) value_max = value;
  }

  min = value_min;
  max = value_max;

}

// with time follow standard and polymorphisme
void PStockLine::SetValues ( UInt_t, std::vector<double> values,
                             Double_t xmin, Double_t xmax, time_t date, UInt_t opt_value )
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry PStockLine::SetValues opt_value " << opt_value << " values[opt] " << values[opt_value] << std::endl;
#endif

  plvalues.push_back( values[ opt_value ]);
  // now compute the middle point from min and max here
  fx.push_back ( ( xmin + xmax ) / 2.0f );
  //std::cout << "( xmin + xmax ) / 2.0f " << ( xmin + xmax ) / 2.0f << std::endl;
  //add date
  dates.push_back ( date );
}

void PStockLine::Resize( unsigned int new_size )
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "PStockLine::Resize add_data new size " << new_size << std::endl;
  std::cout << "old size " << plvalues.size() << std::endl;
#endif
  plvalues.resize ( new_size );
  fx.resize ( new_size );
}

// used ?? yes, necessary ?? not for Candle
// sould clarify the role, kPaint = false for Object it is an Object, not an object Stock...
// PStock Line, kind of mix....may simulate a kpaint ??
// not independent point, kPaint apply to all / nothing here
// object need to be deleted / reset completely, easier
// or improve with intermediate in memory / draw on graph ( sort of copy )
void PStockLine::ClearObjectStock()
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "PStockLine::ClearObjectStock()" << std::endl;
#endif
    plvalues.clear();
    fx.clear();
    // Should set kPaint to false ?? certainly yes
    // Not the fame function here, cannot specify if not want to draw or size is 0
    // SetToPaint( false );
#ifdef DEBUG_OBJSTOCK
    std::cout << "after clear plvalues.size() " << plvalues.size() << std::endl;
    std::cout << "fx.size() " << fx.size() << std::endl;
    //std::cout << "Set to Paint set to false " << std::endl;
#endif
}

// keep this version, used if Collection or normal
int PStockLine::DistancetoPrimitive(int px, int py, AbstractObjectStock** obj ) //const
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry PStockLine::DistancetoPrimitive" << std::endl;
#endif

  //set object by default, problem if want const function
  *obj = this;

  int pxp, pyp, d;
  unsigned int i;
  d = 9999;
  int distance = 9999;

  // really needed ??
  for (i = 0; i < fx.size(); i++) {
      pxp = gPad->XtoAbsPixel(gPad->XtoPad(fx[i]));
      pyp = gPad->YtoAbsPixel(gPad->YtoPad(plvalues[i]));
      d   = TMath::Abs(pxp-px) + TMath::Abs(pyp-py);
      if (d < distance) distance = d;
   }

   // check if point is near one of the connecting lines, ok works
   for (i=0;i< fx.size()-1;i++) {
   //   d = DistancetoLine(px, py, gPad->XtoPad(fx[i]), gPad->YtoPad(plvalues[i]),
   //                      gPad->XtoPad(fx[i+1]), gPad->YtoPad(plvalues[i+1]));
        d = DistancetoLine(px, py, fx[i], gPad->YtoPad(plvalues[i]),
                           fx[i+1], gPad->YtoPad(plvalues[i+1]));
      if (d < distance) distance = d;
   }
   //std::cout << "PStockLine::DistancetoPrimitive return " << distance << std::endl;
   return distance;
}

// Similar to ListObjectStock
int PStockLine::DistancetoPoint( int /*px*/, int py, double & yvalue, int bin ) const
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry PStockLine::distancetoPoint " << std::endl;
  std::cout << "Get input bin " << bin << "value at bin " << plvalues[bin] << std::endl;
#endif
  yvalue = plvalues[bin];
  return TMath::Abs( gPad->YtoAbsPixel( plvalues[bin] ) - py );
}

void PStockLine::Paint( const Option_t* )
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry PStockLine::Paint() " << std::endl;
  std::cout << "fx.size() " << fx.size() << std::endl;
  std::cout << "GetLineColor " << GetLineColor() << std::endl;
  std::cout << "kPaint" << ToPaint() << std::endl;
#endif

  TPolyLine TPLine (fx.size());
  TPLine.SetLineColor ( GetLineColor() );

  for ( UInt_t i=0; i< fx.size(); i++ ) {
      TPLine.SetPoint( i, fx[i], plvalues[i] );
  }
  // test if size=< 1 no line to draw
  if ( TPLine.GetN() >= 2 ) {
      TPLine.Paint();
  }
#ifdef DEBUG_OBJSTOCK
  else {
      std::cout << "TPLine too short do not Paint it" << std::endl;
  }
#endif
}

// use for SMA...
// exactly the same than ListObjectStock, only the SetValues is specific
// small difference in use of xmin/xmax
void PStockLine::SetObjectStock( ListDataStockBase * ldata, CommonXAxis *fcommon_xaxis_th, Hparam_stock_t & Hparam_stock )
{
#ifdef DEBUG_OBJSTOCK
    std::cout << " PStockLine::SetObjectStock " << std::endl;
    //std::cout << "gPad->GetName() " << gPad->GetName() << std::endl;
    // ok this is the TPadStock 1 created
    // std::cout << "gPad " << gPad << std::endl;
    //std::cout << " Hparam_stock.xlast not modified here " << Hparam_stock.xlast << std::endl;
#endif

    std::vector<type_value_data> values;
    std::vector<double> values_intern;
    Double_t xmin,xmax;

    unsigned int xfirst, xlast;
    int shift_left;
    unsigned int size_data = ldata->GetSize();

    ComputeBinRange( ldata, fcommon_xaxis_th, Hparam_stock, xfirst, xlast, shift_left );
    //std::cout << "After ComputeBinRange xfirst/xlast " << xfirst << " " << xlast << std::endl;

    // MUST allocate space before std::copy, seems correct.
    // Again a function GetNbValues would be useful
    values_intern.resize( ldata->NoChronologicAt(0).GetValues().size() );
    //std::cout << "Size of values_intern " << values_intern.size() << std::endl;

    for ( unsigned int bin = xlast ;bin >= xfirst; bin --) {
        //std::cout << "size_data - bin + shift_left " << size_data - bin + shift_left << std::endl;
        // call GetValues of DataStock
        values = ldata->NoChronologicAt( size_data - bin + shift_left ).GetValues();
        // no need of gPad for x values, identical
        xmin = fcommon_xaxis_th->GetXAxis()->GetBinLowEdge(bin);
        xmax = fcommon_xaxis_th->GetXAxis()->GetBinUpEdge(bin);

        // not present with EMA, change something ? get extrema separate, ok like this
        //xmin += (xmax-xmin)*0.1;
        //xmax -= (xmax-xmin)*0.1;

        std::copy ( values.begin(), values.end(), values_intern.begin() );

        // set values for each bin, here transform to its own type, could be float
        //SetValues ( size_data - bin + shift_left, values_intern, xmin, xmax,
        SetValues ( size_data - bin + shift_left, values, xmin, xmax,
            ldata->NoChronologicAt( size_data-bin+shift_left).GetDate() );
    }
    // std::cout << "After ObjectPaint PstockLine " << std::endl;
 }

CollectionObjectStock::CollectionObjectStock( unsigned int size, std::string name_contained, bool ref0 )
  : IndicatorObjectStock( name_contained )
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "Entry Constructor CollectionObjectStock size " << size << std::endl;
    std::cout << "name_contained " << name_contained << std::endl;
    //std::cout << "Indicator label " << indic.label() << std::endl;
    std::cout << "ref0 " << ref0 << std::endl;
#endif
}

CollectionObjectStock::~CollectionObjectStock()
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Destructor CollectionObjectStock" << std::endl;
#endif

  for ( unsigned int i = 0; i < vec_object.size(); i ++ ) {
      delete vec_object[i];
      vec_object[i] = 0;
  }
  vec_object.clear();
  // take out from the list, but do not destry object, to check
  //ArrayObject.Delete();
  //std::cout << "size ArrayObject " << ArrayObject.GetEntriesFast() << std::endl;
}

void CollectionObjectStock::SetParent( THStock * thstock )
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "Entry CollectionObjectStock::SetParent " << std::endl;
#endif
    for ( unsigned i=0; i < vec_object.size(); ++i )
        vec_object[i]->SetParent( thstock );
}

/*
std::vector<std::string> CollectionObjectStock::MakeStringForStatusBar( int px, int py ) const
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "CollectionObject::MakeStringForStatusBar " << std::endl;
#endif

}
*/


// need a function for the factory to add a new object
//void CollectionObjectStock::AddObject( AbstractObjectStock * obj )
void CollectionObjectStock::AddToVecObject( AbstractObjectStock * obj )
{
#ifdef DEBUG_OBJSTOCK
    std::cout << " Entry CollectionObjectStock::AddToVecObject " << std::endl;
#endif
    vec_object.push_back( obj );

}

void CollectionObjectStock::Resize( unsigned int new_size)
{
#ifdef DEBUG_OBJSTOCK
    std::cout << " Entry CollectionObjectStock::Resize " << std::endl;
#endif
    for ( unsigned int i = 0; i < vec_object.size(); i++ )
        vec_object[i]->Resize( new_size );
}

void CollectionObjectStock::GetExtrema( double & min, double & max ) const
{
#ifdef DEBUG_OBJSTOCK
    std::cout << " Entry CollectionObjectStock::GetExtrema " << std::endl;
#endif
    // local and true min, max
    double lmin, lmax;
    double tmin, tmax;

    tmin = 10e6;
    tmax = 0;

    for ( unsigned int i = 0; i <  vec_object.size(); i++ ) {
        vec_object[i]->GetExtrema( lmin, lmax );
        if ( lmin < tmin ) tmin = lmin;
        if ( lmax > tmax ) tmax = lmax;
    }
    min = tmin;
    max = tmax;
}

void CollectionObjectStock::SetValues( unsigned int bin, std::vector<double> values,
        double xmin, double xmax, time_t date, unsigned int /*opt_value*/ )
{
#ifdef DEBUG_OBJSTOCK
    std::cout << "CollectionObjectStock::SetValues " << std::endl;
    std::cout << "vec_object.size() " << vec_object.size() << std::endl;
    std::cout << "values[0] " << values[0] << std::endl;
#endif

    std::vector<double> single_value(1);

    for ( unsigned int i= 0; i < vec_object.size(); i++ ) {
         // extract values, one by one
         single_value[0] = values[i];
         std::cout << "single_value " << single_value[0] << std::endl;
         // assign to the corresponding object
         vec_object[i]->SetValues( bin, single_value, xmin, xmax, date );
    }
}

void CollectionObjectStock::ClearObjectStock()
{
#ifdef DEBUG_OBJSTOCK
    std::cout << " Entry CollectionObjectStock::ClearObjectStock vec_object.size() " << vec_object.size() << std::endl;
#endif
    for ( unsigned int i = 0; i < vec_object.size(); i++ ) {
        // call the base class, never contains candle or bar directly for the moment, only ListObjectStock and PstcokLine
        vec_object[i]->ClearObjectStock();
    }
}
// can be in IndicatorObjectStock !
int CollectionObjectStock::DistancetoPrimitive(Int_t px, Int_t py, AbstractObjectStock** obj) //const
{
#ifdef DEBUG_OBJSTOCK
    std::cout << " Entry CollectionObjectStock::DistancetoPrimitive " << std::endl;
#endif
    //std::cout << "CollectionObjectStock::DistancetoPrimitive() " << std::endl;
    Int_t dist = 9999;
    Int_t dist_objstock = 9999;

    //All collection needa tmp_object ??
    AbstractObjectStock *tmp_object;

    for ( unsigned int i = 0; i < vec_object.size(); i++ ) {
        tmp_object = 0;

        dist_objstock = vec_object[i]->DistancetoPrimitive( px, py, &tmp_object );
        // here call TObject function ?? nothing happens !
        //dist_objstock = vec_object[i]->DistancetoPrimitive( px, py );
        if ( dist_objstock <= dist ) {
            dist = dist_objstock;
            *obj = tmp_object;
              // make same as ListObjectStock, DistancetoPrimitive only px, py or TObject *
              // sufficient, if List cannot get the candle, will get only The list !!
              // certainly need previous version with tmp_object
              //*obj = (vec_object[i]);
              //std::cout << "set to collection obj_tmp " << *obj << " " << (*obj)->ClassName() << std::endl;
        }
    }
#ifdef DEBUG_OBJSTOCK
    std::cout << " aggregate return dist " << dist << std::endl;
    std::cout << " aggregate obj " << *obj << std::endl;
#endif
    //std::cout << " retrun aggregate obj " << *obj << " " << (*obj)->ClassName() << std::endl;
    return dist;
}

void CollectionObjectStock::Paint( const Option_t* option )
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry CollectionObjectStock::Paint size " << vec_object.size() << std::endl;
#endif
  for ( unsigned int i = 0; i <  vec_object.size(); i++ ) {
         // why this test ?
     //if ( dynamic_cast<AbstractObjectStock *>(ArrayObject[i])->ToPaint() )
         //std::cout << "Paint i= " << i << std::endl;
         //ArrayObject[i]->Paint( option );
          if ( vec_object[i]->ToPaint() )
         vec_object[i]->Paint( option );
  }
}

// work for MACD, one indicator, but miss loop over all the ldata ( BOLL forinstance )
//void CollectionObjectStock::SetObjectStock( ListDataStockBase * ldata, CommonXAxis *fcommon_xaxis_th ) //, Hparam_stock_t & Hparam_stock )
void CollectionObjectStock::SetObjectStock( ListDataStockBase * ldata, CommonXAxis *fcommon_xaxis_th, Hparam_stock_t & Hparam_stock )
{
#ifdef DEBUG_OBJSTOCK
  std::cout << "Entry CollectionObjectStock::SetObjectStock vec_object.size() " << vec_object.size() << std::endl;
  //std::cout << "Is really called !!" << std::endl;
#endif

  // here problem if Object return float
  std::vector<type_value_data> values;
  // internally double is used
  std::vector<double> values_intern;
  double xmin,xmax;

  // part common to many object, should use an abstract base function SetParamStock
  // should check redondance with THistPainterStock
/*
#ifdef DEBUG_OBJSTOCK
  std::cout << "list size_data " << size_data << std::endl;
  std::cout << "list size_candle " << size_candle << std::endl;
  std::cout << "new internal shift_left " << shift_left << std::endl;
  std::cout << "Hparam.shift_future /fcommon_xaxis " <<  Hparam_stock.shift_futur << " " << fcommon_xaxis_th->GetShift() << std::endl;
#endif
*/
        unsigned int xfirst, xlast;
    int shift_left;
    unsigned int size_data = ldata->GetSize();

    // MUST allocate space before std::copy, seems correct.
    // Again a function GetNbValues would be useful
    values_intern.resize( ldata->NoChronologicAt(0).GetValues().size() );
    //std::cout << "Size of values_intern " << values_intern.size() << std::endl;

    ComputeBinRange( ldata, fcommon_xaxis_th, Hparam_stock, xfirst, xlast, shift_left );
    //std::cout << "After ComputeBinRange xfirst/xlast " << xfirst << " " << xlast << std::endl;

    for ( unsigned int bin = xlast ;bin >= xfirst; bin-- ) {
       //std::cout << "bin " << bin << std::endl;
       values=ldata->NoChronologicAt( size_data - bin + shift_left ).GetValues();
       //std::cout << "Get values " << values[0] << " " << values[1] << " " << values[2] << std::endl;
       //std::cout << "GetSize values " << values.size() << std::endl;

       // no need of gPad to get x, identical
       xmin = fcommon_xaxis_th->GetXAxis()->GetBinLowEdge(bin);
       xmax = fcommon_xaxis_th->GetXAxis()->GetBinUpEdge(bin);

       // should be done in Candle or Bar if needed
       xmin += (xmax-xmin)*0.1;
       xmax -= (xmax-xmin)*0.1;

       // copy from DataStock type to internal type (always double)
       std::copy ( values.begin(), values.end(), values_intern.begin() );

       SetValues( size_data - bin + shift_left, values_intern, xmin, xmax,
                  ldata->NoChronologicAt( size_data-bin+shift_left).GetDate() );

       // put support to THStock, seems easier
       /* to be before ?? if add resistance
       for ( unsigned int i= 0; i < vec_object.size(); i++ ) {
             std::vector<float> single_value(1);
             single_value[0] = values[i];
             std::cout << "single_value " << single_value[0] << std::endl;
             vec_object[i]->SetValues( size_data - bin + shift_left,
                            single_value, xmin, xmax,
                            ldata->NoChronologicAt( size_data-bin+shift_left).GetDate() );
        }
        */
   }
}