cvn::CVNImageUtils Class Reference

Class containing some utility functions for all things CVN. More...

#include <CVNImageUtils.h>

Public Member Functions
	CVNImageUtils ()
	CVNImageUtils (unsigned int nWires, unsigned int nTDCs, unsigned int nViews)
	~CVNImageUtils ()
void	DisableRegionSelection ()
	Disable the selection of the wire region and just use the first 500 wires. More...
void	EnableRegionSelection ()
	Enable the selection of the wire region. More...
unsigned char	ConvertChargeToChar (float charge)
	Convert the hit charge into the range 0 to 255 required by the CVN. More...
void	SetImageSize (unsigned int nWires, unsigned int nTDCs, unsigned int nViews)
	Set up the image size that we want to have. More...
void	SetViewReversal (bool reverseX, bool reverseY, bool reverseZ)
	Function to set any views that need reversing. More...
void	SetViewReversal (std::vector< bool > reverseViews)
void	SetLogScale (bool setLog)
	Set the log scale for charge. More...
void	SetPixelMapSize (unsigned int nWires, unsigned int nTDCs)
	Set the input pixel map size. More...
void	ConvertPixelMapToPixelArray (const PixelMap &pm, std::vector< unsigned char > &pix)
	Convert a Pixel Map object into a single pixel array with an image size nWire x nTDC. More...
void	ConvertChargeVectorsToPixelArray (std::vector< float > &v0pe, std::vector< float > &v1pe, std::vector< float > &v2pe, std::vector< unsigned char > &pix)
void	ConvertPixelMapToImageVector (const PixelMap &pm, ImageVector &imageVec)
	Convert a pixel map into an image vector (contains all three views) More...
void	ConvertPixelMapToImageVectorF (const PixelMap &pm, ImageVectorF &imageVec)
	Convert a pixel map into an image vector (float version) More...
void	ConvertChargeVectorsToImageVector (std::vector< float > &v0pe, std::vector< float > &v1pe, std::vector< float > &v2pe, ImageVector &imageVec)
	Convert three adc vectors into an image vector (contains all three views) More...
void	ConvertChargeVectorsToImageVectorF (std::vector< float > &v0pe, std::vector< float > &v1pe, std::vector< float > &v2pe, ImageVectorF &imageVec)
	Float version of conversion for convenience of TF interface. More...
void	ConvertPixelArrayToImageVectorF (const std::vector< unsigned char > &pixelArray, ImageVectorF &imageVec)
	Convert a pixel array into a ImageVectorF. More...

Private Member Functions
void	ConvertChargeVectorsToViewVectors (std::vector< float > &v0pe, std::vector< float > &v1pe, std::vector< float > &v2pe, ViewVector &view0, ViewVector &view1, ViewVector &view2)
	Base function for conversion of the Pixel Map to our required output format. More...
ImageVector	BuildImageVector (ViewVector v0, ViewVector v1, ViewVector v2)
	Make the image vector from the view vectors. More...
ImageVectorF	BuildImageVectorF (ViewVectorF v0, ViewVectorF v1, ViewVectorF v2)
void	GetMinMaxWires (std::vector< float > &wireCharges, unsigned int &minWire, unsigned int &maxWire)
	Get the minimum and maximum wires from the pixel map needed to make the image. More...
void	GetMinMaxTDCs (std::vector< float > &tdcCharges, unsigned int &minTDC, unsigned int &maxTDC)
	Get the minimum and maximum tdcs from the pixel map needed to make the image. More...
void	ReverseView (std::vector< float > &peVec)
	Funtion to actually reverse the view. More...
ViewVectorF	ConvertViewVecToViewVecF (ViewVector view)
	Convert a ViewVector into a ViewVectorF. More...
ImageVectorF	ConvertImageVecToImageVecF (ImageVector image)
	Convert a ImageVector into a ImageVectorF. More...

Private Attributes
unsigned int	fNViews
	Number of views of each event. More...
unsigned int	fNWires
	Number of wires to use for the image width. More...
unsigned int	fNTDCs
	Number of TDCs to use for the image height. More...
unsigned int	fPixelMapWires
	Input pixel map sizes. More...
unsigned int	fPixelMapTDCs
std::vector< bool >	fViewReverse
	Vector of bools to decide if any views need to be reversed. More...
bool	fDisableRegionSelection
	Disable the region finding? More...
bool	fUseLogScale
	Use a log scale for charge? More...

Detailed Description

Class containing some utility functions for all things CVN.

Definition at line 24 of file CVNImageUtils.h.

Constructor & Destructor Documentation

cvn::CVNImageUtils::CVNImageUtils

(

)

Definition at line 6 of file CVNImageUtils.cxx.

                               {
  // Set a default image size
  SetImageSize(500,500,3);
  SetPixelMapSize(2880,500);
  // Defualt is to reverse the y view
  fViewReverse = {false,true,false};

  fUseLogScale = false;
  fDisableRegionSelection = false;
}

cvn::CVNImageUtils::CVNImageUtils	(	unsigned int	nWires,
		unsigned int	nTDCs,
		unsigned int	nViews
	)

Definition at line 17 of file CVNImageUtils.cxx.

                                                                                           {
  SetImageSize(nWires,nTDCs,nViews);
  SetPixelMapSize(2880,500);
  fUseLogScale = false;
}

cvn::CVNImageUtils::~CVNImageUtils

(

)

Definition at line 23 of file CVNImageUtils.cxx.

                                {

}

Member Function Documentation

cvn::ImageVector cvn::CVNImageUtils::BuildImageVector ( cvn::ViewVector  v0, cvn::ViewVector  v1, cvn::ViewVector  v2  )

private

Make the image vector from the view vectors.

Definition at line 467 of file CVNImageUtils.cxx.

                                                                                                     {

  // Tensorflow wants things in the arrangement <wires, TDCs, views>
  cvn::ImageVector image;
  for(unsigned int w = 0; w < v0.size(); ++w){
    std::vector<std::vector<unsigned char> > wireVec;
    for(unsigned int t = 0; t < v0[0].size(); ++t){
      std::vector<unsigned char> timeVec;
      timeVec.push_back(v0[w][t]);
      timeVec.push_back(v1[w][t]);
      timeVec.push_back(v2[w][t]);
      wireVec.push_back(timeVec);
    } // Loop over tdcs
    image.push_back(wireVec);
  } // Loop over wires
  
  return image;

}

cvn::ImageVectorF cvn::CVNImageUtils::BuildImageVectorF ( cvn::ViewVectorF  v0, cvn::ViewVectorF  v1, cvn::ViewVectorF  v2  )

private

Definition at line 487 of file CVNImageUtils.cxx.

                                                                                                          {

  // Tensorflow wants things in the arrangement <wires, TDCs, views>
  cvn::ImageVectorF image;
  for(unsigned int w = 0; w < v0.size(); ++w){
    std::vector<std::vector<float> > wireVec;
    for(unsigned int t = 0; t < v0[0].size(); ++t){
      std::vector<float> timeVec;
      timeVec.push_back(v0[w][t]);
      timeVec.push_back(v1[w][t]);
      timeVec.push_back(v2[w][t]);
      wireVec.push_back(timeVec);
    } // Loop over tdcs
    image.push_back(wireVec);
  } // Loop over wires
  
  

  return image;
}

unsigned char cvn::CVNImageUtils::ConvertChargeToChar

(

float

charge

)

Convert the hit charge into the range 0 to 255 required by the CVN.

Definition at line 35 of file CVNImageUtils.cxx.

                                                               {

  float peCorrChunk;
  float truncateCorr;
  float centreScale = 0.7;
  if(fUseLogScale){
    float scaleFrac=(log(charge)/log(1000));
    truncateCorr= ceil(centreScale*scaleFrac*255.0);
      }
  else{
    peCorrChunk = (1000.) / 255.0;
    truncateCorr = ceil((charge)/(peCorrChunk));
  }
  if (truncateCorr > 255) return (unsigned char)255;
  else return (unsigned char)truncateCorr;

}

void cvn::CVNImageUtils::ConvertChargeVectorsToImageVector	(	std::vector< float > &	v0pe,
		std::vector< float > &	v1pe,
		std::vector< float > &	v2pe,
		cvn::ImageVector &	imageVec
	)

Convert three adc vectors into an image vector (contains all three views)

Definition at line 152 of file CVNImageUtils.cxx.

                                                                                                            {

  cvn::ViewVector view0;
  cvn::ViewVector view1;
  cvn::ViewVector view2;

  ConvertChargeVectorsToViewVectors(v0pe, v1pe, v2pe, view0, view1, view2);

  cvn::ImageVector newImage = BuildImageVector(view0,view1,view2);

  imageVec = newImage;
}

void cvn::CVNImageUtils::ConvertChargeVectorsToImageVectorF	(	std::vector< float > &	v0pe,
		std::vector< float > &	v1pe,
		std::vector< float > &	v2pe,
		cvn::ImageVectorF &	imageVec
	)

Float version of conversion for convenience of TF interface.

Definition at line 166 of file CVNImageUtils.cxx.

                                                                                                             {

  cvn::ViewVector view0;
  cvn::ViewVector view1;
  cvn::ViewVector view2;

  ConvertChargeVectorsToViewVectors(v0pe, v1pe, v2pe, view0, view1, view2);

  // Convert the ViewVector to ViewVectorF
  cvn::ViewVectorF floatView0 = ConvertViewVecToViewVecF(view0);
  cvn::ViewVectorF floatView1 = ConvertViewVecToViewVecF(view1);
  cvn::ViewVectorF floatView2 = ConvertViewVecToViewVecF(view2);

  cvn::ImageVectorF newImage = BuildImageVectorF(floatView0,floatView1,floatView2);

  imageVec = newImage;
}

void cvn::CVNImageUtils::ConvertChargeVectorsToPixelArray	(	std::vector< float > &	v0pe,
		std::vector< float > &	v1pe,
		std::vector< float > &	v2pe,
		std::vector< unsigned char > &	pix
	)

Convert three vectors (sorted in the same way as the vectors in the PixelMap object) into a single pixel array with an image size nWire x nTDC

Definition at line 96 of file CVNImageUtils.cxx.

                                                                                                                {

  // Get the vectors
  cvn::ViewVector view0;
  cvn::ViewVector view1;
  cvn::ViewVector view2;
  ConvertChargeVectorsToViewVectors(v0pe, v1pe, v2pe, view0, view1, view2); 

  // Actually write the values to the pixel array
  for (unsigned int view = 0; view < fNViews; ++view){
    for (unsigned int wire = 0; wire < fNWires; ++wire){
      for (unsigned int time = 0; time < fNTDCs; ++time){

        unsigned char val = 0;
        // Get the index for the pixel map
        if(view == 0 ){ val = view0[wire][time]; }
        if(view == 1 ){ val = view1[wire][time]; }
        if(view == 2 ){ val = view2[wire][time]; }

        // Get the index for the final image
        unsigned int i = time + fNTDCs * (wire + fNWires * view);
        pix[i] = val;
  
      }
    }
  }

  return;

}

void cvn::CVNImageUtils::ConvertChargeVectorsToViewVectors ( std::vector< float > &  v0pe, std::vector< float > &  v1pe, std::vector< float > &  v2pe, cvn::ViewVector &  view0, cvn::ViewVector &  view1, cvn::ViewVector &  view2  )

private

Base function for conversion of the Pixel Map to our required output format.

Definition at line 186 of file CVNImageUtils.cxx.

                                                                                                        {

  // Reverse requested views
  if(fViewReverse[0]) ReverseView(v0pe);
  if(fViewReverse[1]) ReverseView(v1pe);
  if(fViewReverse[2]) ReverseView(v2pe);

  // Get the integrated charge for each wire
  std::vector< std::vector<float> > wireCharges;
  for (unsigned int view = 0; view < fNViews; ++view){

    std::vector<float> tempChargeVec;
    for (unsigned int wire = 0; wire < fPixelMapWires; ++wire){

      float totCharge = 0;
      for (unsigned int time = 0; time < fPixelMapTDCs; ++time){
        float val = 0.;
        unsigned int element = time + fPixelMapTDCs * wire;
        if(view == 0 ){ val = v0pe[element]; }
        if(view == 1 ){ val = v1pe[element]; }
        if(view == 2 ){ val = v2pe[element]; }
        totCharge += val;
      }
      tempChargeVec.push_back(totCharge);
    }
    wireCharges.push_back(tempChargeVec);
  }

  // Get the integrated charge for each tdc
  std::vector< std::vector<float> > tdcCharges;
  for (unsigned int view = 0; view < fNViews; ++view){

    std::vector<float> tempChargeVec;
    for (unsigned int time = 0; time < fPixelMapTDCs; ++time){


      float totCharge = 0;
      for (unsigned int wire = 0; wire < fPixelMapWires; ++wire){

        float val = 0.;
        unsigned int element = time + fPixelMapTDCs * wire;
        if(view == 0 ){ val = v0pe[element]; }
        if(view == 1 ){ val = v1pe[element]; }
        if(view == 2 ){ val = v2pe[element]; }
        totCharge += val;
      }
      tempChargeVec.push_back(totCharge);
    }
    tdcCharges.push_back(tempChargeVec);
  }

  // The output image consists of a rectangular region of the pixel map
  // We want to find the start and end wires for each view
  std::vector<unsigned int> imageStartWire(3,0);
  std::vector<unsigned int> imageEndWire(3,0);
  // And the same for TDCs
  std::vector<unsigned int> imageStartTDC(3,0);
  std::vector<unsigned int> imageEndTDC(3,0);

  if(!fDisableRegionSelection){
    // Do a rough vertex-based selection of the region for each view
    for(unsigned int view = 0; view < wireCharges.size(); ++view){
      GetMinMaxWires(wireCharges[view],imageStartWire[view],imageEndWire[view]);
      GetMinMaxTDCs(tdcCharges[view],imageStartTDC[view],imageEndTDC[view]);

//    std::cout << " Wires: " << imageStartWire[view] << ", " << imageEndWire[view] << " :: TDCs: "
//                            << imageStartTDC[view]  << ", " << imageEndTDC[view]  << std::endl;
    }
  }
  else{
    // Just use the number of wires and TDCs as the maximum values if we want to
    // use a fixed range of wires and TDC for protoDUNE's APA 3
    for(unsigned int i = 0; i < imageStartWire.size(); ++i){
      imageStartWire[i] = 0;
      imageEndWire[i] = fNWires;
      imageStartTDC[i] = 0;
      imageEndTDC[i] = fNTDCs;
    }
  }

  // Write the values to the three vectors
  for (unsigned int view = 0; view < fNViews; ++view){
    cvn::ViewVector viewChargeVec;
    for (unsigned int wire = imageStartWire[view]; wire <= imageEndWire[view]; ++wire){
      std::vector<unsigned char> wireTDCVec;
      for (unsigned int time = imageStartTDC[view]; time <= imageEndTDC[view]; ++time){

        // Get the index for the pixel map
        unsigned int element = time + fPixelMapTDCs * wire;

        // We have to convert to char and then convert back to a float
        unsigned char val = 0;
        if(view == 0){ val = ConvertChargeToChar(v0pe[element]); }
        if(view == 1){ val = ConvertChargeToChar(v1pe[element]); }
        if(view == 2){ val = ConvertChargeToChar(v2pe[element]); }
        wireTDCVec.push_back(val);
      }
      viewChargeVec.push_back(wireTDCVec);
    }
    if(view == 0) view0 = viewChargeVec;
    if(view == 1) view1 = viewChargeVec;
    if(view == 2) view2 = viewChargeVec;
  }

  return;

}

cvn::ImageVectorF cvn::CVNImageUtils::ConvertImageVecToImageVecF ( cvn::ImageVector  image )

private

Convert a ImageVector into a ImageVectorF.

Definition at line 449 of file CVNImageUtils.cxx.

                                                                                {

  cvn::ImageVectorF newImage; 
  for(size_t w = 0; w < image.size(); ++w){
    cvn::ViewVectorF thisWire;
    for(size_t t = 0; t < image[w].size(); ++t){
      std::vector<float> thisTime;
      for(size_t v = 0; v < image[w][t].size(); ++v){
        float chargeSC = static_cast<float>(image[w][t][v]);
        thisTime.push_back(chargeSC);
      }
      thisWire.push_back(thisTime);
    }
    newImage.push_back(thisWire);
  }
  return newImage;
}

void cvn::CVNImageUtils::ConvertPixelArrayToImageVectorF	(	const std::vector< unsigned char > &	pixelArray,
		cvn::ImageVectorF &	imageVec
	)

Convert a pixel array into a ImageVectorF.

Definition at line 295 of file CVNImageUtils.cxx.

                                                                                                                           {

  // The pixel arrays is built with indices i = tdc + nTDCs(wire + nWires*view)

  cvn::ViewVectorF view0; 
  cvn::ViewVectorF view1; 
  cvn::ViewVectorF view2;
 
  for(unsigned int v = 0; v < fNViews; ++v){
    for(unsigned int w = 0; w < fNWires; ++w){
      std::vector<float> wireVec;
      for(unsigned int t = 0; t < fNTDCs; ++t){
        unsigned int index = t + fNTDCs*(w + fNWires*v);
        wireVec.push_back(pixelArray[index]);
      }
      if(v==0) view0.push_back(wireVec);
      if(v==1) view1.push_back(wireVec);
      if(v==2) view2.push_back(wireVec);
    }
  }

  imageVec = BuildImageVectorF(view0,view1,view2);

}

void cvn::CVNImageUtils::ConvertPixelMapToImageVector	(	const PixelMap &	pm,
		cvn::ImageVector &	imageVec
	)

Convert a pixel map into an image vector (contains all three views)

Definition at line 128 of file CVNImageUtils.cxx.

                                                                                                  {

  SetPixelMapSize(pm.fNWire,pm.fNTdc);

  // Strip out the charge vectors and use these
  std::vector<float> v0pe = pm.fPEX;
  std::vector<float> v1pe = pm.fPEY;
  std::vector<float> v2pe = pm.fPEZ;

  ConvertChargeVectorsToImageVector(v0pe, v1pe, v2pe, imageVec);
}

void cvn::CVNImageUtils::ConvertPixelMapToImageVectorF	(	const PixelMap &	pm,
		cvn::ImageVectorF &	imageVec
	)

Convert a pixel map into an image vector (float version)

Definition at line 140 of file CVNImageUtils.cxx.

                                                                                                    {

  SetPixelMapSize(pm.fNWire,pm.fNTdc);

  // Strip out the charge vectors and use these
  std::vector<float> v0pe = pm.fPEX;
  std::vector<float> v1pe = pm.fPEY;
  std::vector<float> v2pe = pm.fPEZ;

  ConvertChargeVectorsToImageVectorF(v0pe, v1pe, v2pe, imageVec);
}

void cvn::CVNImageUtils::ConvertPixelMapToPixelArray	(	const PixelMap &	pm,
		std::vector< unsigned char > &	pix
	)

Convert a Pixel Map object into a single pixel array with an image size nWire x nTDC.

Definition at line 82 of file CVNImageUtils.cxx.

                                                                                                   {

  SetPixelMapSize(pm.fNWire,pm.fNTdc);

  // Strip out the charge vectors and use these
  std::vector<float> v0pe = pm.fPEX;
  std::vector<float> v1pe = pm.fPEY;
  std::vector<float> v2pe = pm.fPEZ;

  ConvertChargeVectorsToPixelArray(v0pe,v1pe,v2pe,pix);

}

cvn::ViewVectorF cvn::CVNImageUtils::ConvertViewVecToViewVecF ( cvn::ViewVector  view )

private

Convert a ViewVector into a ViewVectorF.

Definition at line 435 of file CVNImageUtils.cxx.

                                                                           {

  cvn::ViewVectorF newVec; 
  for(size_t w = 0; w < view.size(); ++w){
    std::vector<float> thisWire;
    for(size_t t = 0; t < view[w].size(); ++t){
      float chargeSC = static_cast<float>(view[w][t]);
      thisWire.push_back(chargeSC);
    }
    newVec.push_back(thisWire);
  }
  return newVec;
}

void cvn::CVNImageUtils::DisableRegionSelection

(

)

Disable the selection of the wire region and just use the first 500 wires.

Definition at line 27 of file CVNImageUtils.cxx.

                                             {
  fDisableRegionSelection = true;
}

void cvn::CVNImageUtils::EnableRegionSelection

(

)

Enable the selection of the wire region.

Definition at line 31 of file CVNImageUtils.cxx.

                                            {
  fDisableRegionSelection = false;
}

void cvn::CVNImageUtils::GetMinMaxTDCs ( std::vector< float > &  tdcCharges, unsigned int &  minTDC, unsigned int &  maxTDC  )

private

Get the minimum and maximum tdcs from the pixel map needed to make the image.

Definition at line 365 of file CVNImageUtils.cxx.

                                                                                                            {

  minTDC = 0;
  maxTDC = fNTDCs;

  for(unsigned int tdc = 0; tdc < tdcCharges.size(); ++tdc){

    // If we have got to fNWires from the end, the start needs to be this wire
    if(tdcCharges.size() - tdc == fNTDCs){
      break;
    } 

    // For a given tdc, look to see if the next 20 tdcs are empty. If not, this can be out start tdc.
    int nEmpty = 0;
    for(unsigned int nextTDC = tdc + 1; nextTDC <= tdc + 20; ++nextTDC){
      if(tdcCharges[nextTDC] == 0.0) ++nEmpty;
    } 
    if(nEmpty < 5){
      minTDC = tdc;
      maxTDC = tdc + fNTDCs - 1;
      return;
    } 
  }

  // If we don't find a region where we have fewer than 5 empty tdcs then we just want to select the fNTDCs tdcs containing
  // the most charge
  float maxCharge = 0.;
  unsigned int firstTDC = 0;
  for(unsigned int tdc = 0; tdc < tdcCharges.size() - fNTDCs; ++tdc){
    float windowCharge = 0.;
    for(unsigned int nexttdc = tdc; nexttdc < tdc + fNTDCs; ++nexttdc){
      windowCharge += tdcCharges[nexttdc];
    }
    if(windowCharge > maxCharge){
      maxCharge = windowCharge;
      firstTDC = tdc;
    }
  }
  minTDC = firstTDC;
  maxTDC = firstTDC + fNTDCs - 1;

  std::cout << "Used alternate method to get min and max tdcs due to vertex determination failure: " << minTDC << ", " << maxTDC << std::endl;


}

void cvn::CVNImageUtils::GetMinMaxWires ( std::vector< float > &  wireCharges, unsigned int &  minWire, unsigned int &  maxWire  )

private

Get the minimum and maximum wires from the pixel map needed to make the image.

Definition at line 320 of file CVNImageUtils.cxx.

                                                                                                                {

  minWire = 0;
  maxWire = fNWires;

  for(unsigned int wire = 0; wire < wireCharges.size(); ++wire){

    // If we have got to fNWires from the end, the start needs to be this wire
    if(wireCharges.size() - wire == fNWires){
      break;
    }

    // For a given plane, look to see if the next 20 planes are empty. If not, this can be out start plane.
    int nEmpty = 0;
    for(unsigned int nextWire = wire + 1; nextWire <= wire + 20; ++nextWire){
      if(wireCharges[nextWire] == 0.0) ++nEmpty;
    }
    if(nEmpty < 5){
      minWire = wire;
      maxWire = wire + fNWires - 1;
      return;
    }
  }

  // If we don't find a region where we have fewer than 5 empty planes then we just want to select the fNWires wires containing
  // the most charge
  float maxCharge = 0.;
  unsigned int firstWire = 0;
  for(unsigned int wire = 0; wire < wireCharges.size() - fNWires; ++wire){
    float windowCharge = 0.;
    for(unsigned int nextwire = wire; nextwire < wire + fNWires; ++nextwire){
      windowCharge += wireCharges[nextwire];
    } 
    if(windowCharge > maxCharge){
      maxCharge = windowCharge;
      firstWire = wire;
    }
  } 
  minWire = firstWire;
  maxWire = firstWire + fNWires - 1;

  std::cout << "Used alternate method to get min and max wires due to vertex determination failure: " << minWire << ", " << maxWire << std::endl;

}

void cvn::CVNImageUtils::ReverseView ( std::vector< float > &  peVec )

private

Funtion to actually reverse the view.

Definition at line 411 of file CVNImageUtils.cxx.

                                                         {

  std::vector<float> vecCopy(peVec.size(),0.); 

  for (unsigned int w = 0; w < fPixelMapWires; ++w)
  {
    // Get our new plane number
    unsigned int newPlane = fPixelMapWires - w - 1;

    for (unsigned int t = 0; t < fPixelMapTDCs; ++t)
    {
      float val = peVec[t + fPixelMapTDCs * w];
      vecCopy[t + fPixelMapTDCs * newPlane] = val;
    }
  }

  // Copy the values back into the original vector
  for(unsigned int e = 0; e < peVec.size(); ++e){
    float val = vecCopy[e];
    peVec[e] = val;
  }

}

void cvn::CVNImageUtils::SetImageSize	(	unsigned int	nWires,
		unsigned int	nTDCs,
		unsigned int	nViews
	)

Set up the image size that we want to have.

Definition at line 53 of file CVNImageUtils.cxx.

                                                                                               {
  fNWires = nWires;
  fNTDCs = nTDCs;
  fNViews = nViews;
}

void cvn::CVNImageUtils::SetLogScale

(

bool

setLog

)

Set the log scale for charge.

Definition at line 73 of file CVNImageUtils.cxx.

                                             {
  fUseLogScale = setLog;
}

void cvn::CVNImageUtils::SetPixelMapSize	(	unsigned int	nWires,
		unsigned int	nTDCs
	)

Set the input pixel map size.

Definition at line 77 of file CVNImageUtils.cxx.

                                                                             {
  fPixelMapWires = nWires;
  fPixelMapTDCs = nTDCs;
}

void cvn::CVNImageUtils::SetViewReversal	(	bool	reverseX,
		bool	reverseY,
		bool	reverseZ
	)

Function to set any views that need reversing.

Definition at line 59 of file CVNImageUtils.cxx.

                                                                                 {
  fViewReverse = {reverseX,reverseY,reverseZ};
}

void cvn::CVNImageUtils::SetViewReversal

(

std::vector< bool >

reverseViews

)

Definition at line 63 of file CVNImageUtils.cxx.

                                                                  {
  if(reverseViews.size() != 3){
    std::cout << "Expected three views for view reversals... using defaults." << std::endl;
  }
  else{
    SetViewReversal(reverseViews[0],reverseViews[1],reverseViews[2]);
  }
  return;
}

Member Data Documentation

bool cvn::CVNImageUtils::fDisableRegionSelection

private

Disable the region finding?

Definition at line 119 of file CVNImageUtils.h.

unsigned int cvn::CVNImageUtils::fNTDCs

private

Number of TDCs to use for the image height.

Definition at line 109 of file CVNImageUtils.h.

unsigned int cvn::CVNImageUtils::fNViews

private

Number of views of each event.

Definition at line 103 of file CVNImageUtils.h.

unsigned int cvn::CVNImageUtils::fNWires

private

Number of wires to use for the image width.

Definition at line 106 of file CVNImageUtils.h.

unsigned int cvn::CVNImageUtils::fPixelMapTDCs

private

Definition at line 113 of file CVNImageUtils.h.

unsigned int cvn::CVNImageUtils::fPixelMapWires

private

Input pixel map sizes.

Definition at line 112 of file CVNImageUtils.h.

bool cvn::CVNImageUtils::fUseLogScale

private

Use a log scale for charge?

Definition at line 122 of file CVNImageUtils.h.

std::vector<bool> cvn::CVNImageUtils::fViewReverse

private

Vector of bools to decide if any views need to be reversed.

Definition at line 116 of file CVNImageUtils.h.

---

The documentation for this class was generated from the following files:

• dunereco/dunereco/CVN/func/CVNImageUtils.h
• dunereco/dunereco/CVN/func/CVNImageUtils.cxx