KJB
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Classes | Typedefs | Functions
DTLib Namespace Reference

Classes

class  CAffine
 
class  CCircleMasks
 
class  CDOG
 
class  CFilterbank
 
class  CGaussKernel
 
class  CHistogram
 
class  CImgVec
 
class  CImg
 
class  CJPEG
 
class  CKMeans
 
struct  MATFILE
 
class  CSparsePatImg
 
class  CTextureScale
 

Typedefs

typedef CHistogram< float > * FloatCHistogramPtr
 TYPES. More...
 
typedef CHistogram< int > * IntCHistogramPtr
 
typedef CHistogram< long > * LongCHistogramPtr
 
typedef CImg< BYTE > * ByteCImgPtr
 TYPES. More...
 
typedef CImg< kjb_int32 > * LongCImgPtr
 
typedef CImg< float > * FloatCImgPtr
 
typedef CImg< int > * IntCImgPtr
 
typedef CImgVec< BYTE > * ByteCImgVecPtr
 
typedef CImgVec< kjb_int32 > * LongCImgVecPtr
 
typedef CImgVec< float > * FloatCImgVecPtr
 
typedef vector< CImg< BYTE >
* >::iterator 
ByteImgVecIter
 
typedef vector< CImg
< kjb_int32 > * >::iterator 
LongImgVecIter
 
typedef vector< CImg< float >
* >::iterator 
FloatImgVecIter
 
typedef vector< CImg< int >
* >::iterator 
IntImgVecIter
 

Functions

void SeparateChannels (CImg< kjb_int32 > &InCombImg, CImgVec< BYTE > &OutChannelVec, const kjb_int32 &nSegments)
 
int CircumLength (const int &radius)
 
int * ComputeCircum (const int &radius, const int &Width)
 
void BGR2Gray (unsigned char *pInBuf, unsigned char *pOutBuf, const int &Width, const int &Height)
 
void BGR2LAB (float *pInBuf, float *pOutBuf, const int &Width, const int &Height, const float &Gamma=DEFAULT_GAMMA)
 
void BGR2L (unsigned char *pInBuf, float *pOutBuf, const int &Width, const int &Height, const float &Gamma=DEFAULT_GAMMA)
 
void BGR2Srg (float *pInBuf, float *pOutBuf, const int &Width, const int &Height)
 
template<class T >
void Interleaved2Planar (T *pIn, T *pOut1, T *pOut2, T *pOut3, const int &Width, const int &Height)
 
CImg< FloatCHistogramPtr > * MakeEmptyColorHistoImg (const int &Width, const int &Height, const int &nAs, const int &nBs, const int &nCs, const float &minA, const float &maxA, const float &minB, const float &maxB, const float &minC, const float &maxC)
 
CImg< FloatCHistogramPtr > * MakeBWEmptyColorHistoImg (const int &Width, const int &Height, const int &nAs, const float &minA, const float &maxA)
 
void ComputeColorHistogramImg (CCircleMasks *pCircleMasks, FloatCImgPtr pTextureScaleImg, FloatCImgPtr pColorAImg, FloatCImgPtr pColorBImg, CImg< FloatCHistogramPtr > *pColorHistoImg, LongCImgPtr pPresegImg, const float &SoftUpdateSigma)
 
void ComputeColorHistogramImgNew (CCircleMasks *pCircleMasks, FloatCImgPtr pTextureScaleImg, FloatCImgPtr pColorAImg, FloatCImgPtr pColorBImg, FloatCImgPtr pColorCImg, CImg< FloatCHistogramPtr > *pColorHistoImg, LongCImgPtr pPresegImg, const float &SoftUpdateSigma)
 
void ComputeColorHistogramImg2Old (CCircleMasks *pCircleMasks, FloatCImgPtr pTextureScaleImg, FloatCImgPtr pColorAImg, FloatCImgPtr pColorBImg, CImg< FloatCHistogramPtr > *pColorHistoImg, LongCImgPtr pPresegImg, const float &SoftUpdateSigma)
 
void ComputeColorHistogramImgBWNew (CCircleMasks *pCircleMasks, FloatCImgPtr pTextureScaleImg, FloatCImgPtr pColorAImg, CImg< FloatCHistogramPtr > *pColorHistoImg, LongCImgPtr pPresegImg, const float &SoftUpdateSigma)
 
void CombineScalesNMSRhoTheta (const int &nGaussScales, CImgVec< BYTE > &InNMSVec, CImgVec< float > &InEnergyVec, CImgVec< float > &InOriVec, CImg< BYTE > &OutNMSCombImg, CImg< float > &OutEnergyCombImg, CImg< float > &OutOriCombImg)
 
void Convolve (CImg< float > &InImg, CImg< float > &KernelImg, CImg< float > &OutImg)
 
void MakeDualLattice (const float &EdgelLength, const float &SigmaIC, const int &nGaussScales, CImgVec< BYTE > &InNMSVec, CImgVec< float > &InEnergyVec, CImgVec< float > &InOriVec, CImgVec< float > &InXLocVec, CImgVec< float > &InYLocVec, CImg< float > &InPTextureImg, CImg< float > &OutDualHImg, CImg< float > &OutDualVImg)
 
void fft_free ()
 
int fftn (int ndim, const int dims[], double Re[], double Im[], int isign, double scaling)
 
int fftnf (int ndim, const int dims[], float Re[], float Im[], int isign, double scaling)
 
void FwdFFT (float *aRe, float *aIm, const int Size)
 
void InvFFT (float *aRe, float *aIm, const int Size)
 
void GetTextureFeatures (int *SegBuf, int Width, int Height, int nGaussScales, int nGaussOrientations, CImgVec< float > &OEVec, CImgVec< float > &ConvVec, int nDOGScales, kjb::Matrix &Oe_mean, kjb::Matrix &Oe_var, kjb::Matrix &DOG_mean, kjb::Matrix &DOG_var)
 
void Hilbert (float *aInVector, const int Length)
 
void report_int (const std::string &msg, int value)
 
bool LinesIntersect (const int &x1, const int &y1, const int &x2, const int &y2, const int &x3, const int &y3, const int &x4, const int &y4)
 
bool LinesIntersect (const float &x1, const float &y1, const float &x2, const float &y2, const float &x3, const float &y3, const float &x4, const float &y4)
 
template<class T >
T * ReadBufferFromMatfile (const char *strFilename, T *pBuffer, int &Width, int &Height)
 
template<class T >
bool WriteBufferToMatfile (T *pBuffer, const int Width, const int Height, const char *strMatName, const char *strFilename)
 
template<class T >
bool ReadMatfile (CImg< T > *pInImg, const char *strFilename)
 
void ReadMatheader (const char *strFilename)
 
template<class T >
bool WriteMatfile (CImg< T > &InImg, const char *strMatname, const char *strFilename)
 
template<class T >
bool WriteMatfile (CImg< T > &InImg, const char *strMatname)
 
template<class T >
bool ReadMatfiles (CImgVec< T > &InVec, const char *strPrefix)
 
template<class T >
bool WriteMatfiles (CImgVec< T > &InVec, const char *strPrefix)
 
template<class T >
bool WriteMatfiles (const vector< CImg< T > * > &InVec, const char *strPrefix)
 
int MatlabTypeID (float *pBuffer)
 
int MatlabTypeID (unsigned char *pBuffer)
 
int MatlabTypeID (int *pBuffer)
 
template<class T >
bool ReadMatfile (CImg< T > &InImg, const char *strFilename)
 
void MedianFilter (CImg< float > &InImg, CImg< float > &OutImg, const int &Radius)
 
void nrerror (char error_text[])
 
float * fvector (long nl, long nh)
 
int * ivector (long nl, long nh)
 
unsigned char * cvector (long nl, long nh)
 
kjb_uint32 * lvector (long nl, long nh)
 
double * dvector (long nl, long nh)
 
float ** matrix (long nrl, long nrh, long ncl, long nch)
 
double ** dmatrix (long nrl, long nrh, long ncl, long nch)
 
int ** imatrix (long nrl, long nrh, long ncl, long nch)
 
float ** submatrix (float **a, long oldrl, long oldrh, long oldcl, long oldch, long newrl, long newcl)
 
float ** convert_matrix (float *a, long nrl, long nrh, long ncl, long nch)
 
float *** f3tensor (long nrl, long nrh, long ncl, long nch, long ndl, long ndh)
 
void free_fvector (float *v, long nl, long nh)
 
void free_ivector (int *v, long nl, long nh)
 
void free_cvector (unsigned char *v, long nl, long nh)
 
void free_lvector (kjb_uint32 *v, long nl, long nh)
 
void free_dvector (double *v, long nl, long nh)
 
void free_matrix (float **m, long nrl, long nrh, long ncl, long nch)
 
void free_dmatrix (double **m, long nrl, long nrh, long ncl, long nch)
 
void free_imatrix (int **m, long nrl, long nrh, long ncl, long nch)
 
void free_submatrix (float **b, long nrl, long nrh, long ncl, long nch)
 
void free_convert_matrix (float **b, long nrl, long nrh, long ncl, long nch)
 
void free_f3tensor (float ***t, long nrl, long nrh, long ncl, long nch, long ndl, long ndh)
 
void ludcmp (float **a, int n, int *indx, float *d)
 
void lubksb (float **a, int n, int *indx, float *b)
 
float * zero_fvector (long nl, long nh)
 
void mat_transpose (float **m1, float **mres, long nrl, long nrh, long ncl, long nch)
 
float ** diag_matrix (float diagVal, long nrl, long nrh, long ncl, long nch)
 
float ** zero_matrix (long nrl, long nrh, long ncl, long nch)
 
float * mat_diag_fvector (float **mat, long nrl, long nrh, long ncl, long nch)
 
float inner (float *x, float *y, long nl, long nh)
 
void mat_vec_prod (float **A, float *x, float *y, long nrl, long nrh, long ncl, long nch)
 
void mat_mat_prod (float **A, float **B, float **res, long nrl, long nrh, long ncl, long nch, long ncl2, long nch2)
 
void mat_mat_sum (float **A, float **B, float **res, long nrl, long nrh, long ncl, long nch)
 
void mat_mat_diff (float **A, float **B, float **res, long nrl, long nrh, long ncl, long nch)
 
float ran1 (long *idum)
 
float gasdev (long *idum)
 
float ** rand_matrix (long nrl, long nrh, long ncl, long nch)
 
void scal_vec_prod (float s, float *v, float *res, long nl, long nh)
 
void vec_vec_prod (float *a, float *b, float *res, long nl, long nh)
 
void vec_vec_diff (float *a, float *b, float *res, long nl, long nh)
 
void vec_vec_sum (float *a, float *b, float *res, long nl, long nh)
 
void vec_vec_assign (float *a, float *b, long nl, long nh)
 
void scal_mat_prod (float s, float **m, float **res, long nrl, long nrh, long ncl, long nch)
 
float ** copy_mat (float **m, long nrl, long nrh, long ncl, long nch)
 
void mat_inverse (float **m, float **res, long n)
 
void trace_mat (float **m, long nrl, long nrh, long ncl, long nch)
 
void trace_vec (float *v, long nl, long nh)
 
void diag_matrix_from_vec (float *v, float **m, long nl, long nh)
 
void OrientationEnergy (const int &nGaussScales, const int &nGaussOrientations, CImgVec< float > &ConvVec, CImgVec< float > &OEVec)
 
void GetSuccessiveOEThetaPairs (CImgVec< float > &OEVec, const int &nGaussOrientations, const int &iScale, const int &iTheta, const int &x, const int &y, int &iPrevTheta, int &iNextTheta, float &PrevTheta, float &Theta, float &NextTheta, float &PrevOE, float &OE, float &NextOE)
 
void ParabolicOrientationsFit (const int &nGaussScales, const int &nGaussOrientations, CImgVec< float > &OEVec, CImgVec< float > &RhoVec, CImgVec< float > &ThetaVec, CImgVec< BYTE > &ThetaIdxVec)
 
void InterpolateOrientations (const int &iScale, const int &nGaussOrientations, CImgVec< float > &OEVec, CImgVec< BYTE > &ThetaIdxVec, CImgVec< float > &ThetaVec)
 
void ComputePTextureImg (CCircleMasks &CircleMasks, CImg< BYTE > &NMSCombImg, CImg< float > &ThetaStarImg, CImg< float > &TextureScaleImg, CImg< kjb_int32 > &TextonMembershipImg, const int &K, const float &DiskMiddleBandThickness, const float &Tau, const float &Beta, CImg< float > &PTextureImg)
 
template<class T >
void Reflect (CImg< T > &InImg, CImg< T > &OutImg)
 
template<class T >
void Rotate (CImg< T > &InImg, CImg< T > &OutImg, const double &Theta, const T &BGVal=0)
 
void SubpixelLocalization (const int &nGaussScales, const int &nGaussOrientations, CImgVec< float > &OESeq, CImgVec< BYTE > &ThetaIdxSeq, CImgVec< BYTE > &MaximaSeq, CImgVec< float > &RhoStarSeq, CImgVec< float > &ThetaSeq, CImgVec< float > &XLocSeq, CImgVec< float > &YLocSeq, CImgVec< float > &ErrSeq)
 
CImg< FloatCHistogramPtr > * MakeEmptyTextonHistoImg (const int &Width, const int &Height, const int &K)
 
void ComputeTextonHistogramImg (CCircleMasks *pCircleMasks, FloatCImgPtr pTextureScaleImg, CImg< kjb_int32 > *pTextonsImg, FloatCImgPtr pPTextureImg, CImg< FloatCHistogramPtr > *pTextonHistoImg, CImg< kjb_int32 > *pPresegImg=NULL)
 
void FilterbankConvolve (FloatCImgPtr m_pInputImage, CFilterbank **m_pFilterbank_ptr, FloatCImgVecPtr *m_pConvVec_ptr, int m_nGaussScales, int m_nGaussOrientations, float m_GaussSigmaY, float m_GaussX2YSigmaRatio, int m_nDOGScales, float m_DOGExcitSigma, float m_DOGInhibSigmaRatio1, float m_DOGInhibSigmaRatio2)
 
void ComputeOrientationEnergy (FloatCImgPtr m_pInputImage, CFilterbank *m_pFilterbank, FloatCImgVecPtr m_pConvVec, FloatCImgVecPtr *m_pOEVec, int m_nGaussScales, int m_nGaussOrientations)
 
void extract_texture (const kjb::Image &img, const kjb::Int_matrix &seg_map, kjb::Matrix &Oe_mean, kjb::Matrix &Oe_var, kjb::Matrix &DOG_mean, kjb::Matrix &DOG_var, int m_nGaussScales, int m_nGaussOrientations, float m_GaussSigmaY, float m_GaussX2YSigmaRatio, int m_nDOGScales, float m_DOGExcitSigma, float m_DOGInhibSigmaRatio1, float m_DOGInhibSigmaRatio2, int m_nCroppedPixels)
 
FloatCImgPtr convert_kjb_to_CImg (const kjb::Image &img, FloatCImgPtr *m_pAImg, FloatCImgPtr *m_pBImg, int m_nCroppedPixels, bool &m_bColor)
 
void do_textons (FloatCImgVecPtr m_pConvVec, LongCImgPtr *m_pTextonsImg, int m_nGaussScales, int m_nGaussOrientations, int m_nDOGScales, int m_InputWidth, int m_InputHeight, int m_nTextureKMeansK, int m_nTextureKMeansIterations)
 
void ComputeTextonHistoImg ()
 
CCircleMasksComputeCircleMasks (int m_minTextureScale, int m_maxTextureScale)
 
FloatCImgPtr ComputeTextureScale (LongCImgPtr m_pTextonsImg, CTextureScale **m_pTS, int m_InputWidth, int m_InputHeight, int m_nTextureKMeansK, float m_TextureMinDist, float m_TextureMaxDist, float m_TextureAlphaScaleFactor, int &m_minTextureScale, int &m_maxTextureScale)
 
FloatCImgPtr ComputePTexture (DTLib::CCircleMasks *m_pCircleMasks, FloatCImgPtr m_pTextureScaleImg, LongCImgPtr m_pTextonsImg, ByteCImgPtr m_pNMSCombImg, FloatCImgPtr m_pOriCombImg, int m_InputWidth, int m_InputHeight, int m_minTextureScale, int m_maxTextureScale, int m_nTextureKMeansK, float m_TextureDiskMiddleWidth, float m_TextureTau, float m_TextureBeta)
 
void ComputeNonmaximaSuppression (CFilterbank *m_pFilterbank, FloatCImgVecPtr m_pOEVec, CImgVec< BYTE > **m_pNMSVec, CImgVec< float > **m_pEnergyVec, CImgVec< float > **m_pOriVec, CImgVec< float > **m_pXLocVec, CImgVec< float > **m_pYLocVec, CImgVec< float > **m_pErrVec, int m_nGaussScales, int m_nGaussOrientations, int m_InputWidth, int m_InputHeight)
 
void CombineScales (CImgVec< BYTE > *m_pNMSVec, CImgVec< float > *m_pEnergyVec, CImgVec< float > *m_pOriVec, ByteCImgPtr *m_pNMSCombImg, FloatCImgPtr *m_pOriCombImg, FloatCImgPtr *m_pEnergyCombImg, int m_InputWidth, int m_InputHeight, int m_nGaussScales)
 
void ComputeTextonHistoImg (LongCImgPtr m_pTextonsImg, FloatCImgPtr m_pTextureScaleImg, FloatCImgPtr m_pPTextureImg, DTLib::CCircleMasks *m_pCircleMasks, CImg< FloatCHistogramPtr > **m_pTextonHistoImg, int m_InputWidth, int m_InputHeight, int m_nTextureKMeansK)
 
void ComputeWeberLaw (CFilterbank *m_pFilterbank_ptr, FloatCImgVecPtr m_pConvVec_ptr, float m_TextureWeberLawConst)
 
void Compute_Textons_Histograms (const kjb::Image &img, CImg< FloatCHistogramPtr > **m_pTextonHistoImg, CImg< FloatCHistogramPtr > **ColorHist, FloatCImgPtr *m_pDualHImg, FloatCImgPtr *m_pDualVImg, ByteCImgPtr *m_pSparsePatImg, int m_nGaussScales, int m_nGaussOrientations, float m_GaussSigmaY, float m_GaussX2YSigmaRatio, int m_nDOGScales, float m_DOGExcitSigma, float m_DOGInhibSigmaRatio1, float m_DOGInhibSigmaRatio2, int m_nCroppedPixels, float m_TextureWeberLawConst, int m_nTextureKMeansK, int m_nTextureKMeansIterations, float m_TextureMinDist, float m_TextureMaxDist, float m_TextureAlphaScaleFactor, float m_TextureDiskMiddleWidth, float m_TextureTau, float m_TextureBeta, int m_nBinsA, int m_nBinsB, int m_nBinsC, float m_ColorHistoSoftBinSigma, float m_EdgelLength, float m_InterveningContourSigma, int m_SparsePatternDenseRad, int m_SparsePatternMaxRad, int m_nSparsePatternSamples, bool &m_bColor)
 
void Compute_All_Histograms (const kjb::Image &img, CImg< FloatCHistogramPtr > **m_pTextonHistoImg, CImg< FloatCHistogramPtr > **ColorHist)
 
void ComputeColorHistoImg (const kjb::Image &img, CImg< FloatCHistogramPtr > **ColorHist, int m_nBinsA=8, int m_nBinsB=8, int m_nBinsC=8, float m_ColorHistoSoftBinSigma=1.8f, int m_nCroppedPixels=10, int m_nGaussScales=3, int m_nGaussOrientations=12, float m_GaussSigmaY=1.41f, float m_GaussX2YSigmaRatio=3.0f, int m_nDOGScales=3, float m_DOGExcitSigma=1.41f, float m_DOGInhibSigmaRatio1=0.62f, float m_DOGInhibSigmaRatio2=1.6f, float m_TextureMinDist=3.0f, float m_TextureMaxDist=0.1f, float m_TextureAlphaScaleFactor=1.5f, float m_TextureDiskMiddleWidth=3.0f)
 
CImg< FloatCHistogramPtr > * ComputeColorHistoImg (FloatCImgPtr m_pTextureScaleImg, CCircleMasks *m_pCircleMasks, FloatCImgPtr m_pAImg, FloatCImgPtr m_pBImg, FloatCImgPtr m_pCImg, int m_InputWidth, int m_InputHeight, int m_nBinsA, int m_nBinsB, int m_nBinsC, float m_ColorHistoSoftBinSigma, bool is_colour)
 
void ComputeDualLattice (CImgVec< float > *m_pEnergyVec, CImgVec< float > *m_pOriVec, CImgVec< BYTE > *m_pNMSVec, CImgVec< float > *m_pXLocVec, CImgVec< float > *m_pYLocVec, FloatCImgPtr m_pPTextureImg, FloatCImgPtr *m_pDualHImg, FloatCImgPtr *m_pDualVImg, int m_InputWidth, int m_InputHeight, int m_nGaussScales, float m_EdgelLength, float m_InterveningContourSigma)
 
ByteCImgPtr ComputeSparsePattern (int m_SparsePatternDenseRad, int m_SparsePatternMaxRad, int m_nSparsePatternSamples)
 
CImg< FloatCHistogramPtr > * ReadHistoImg (const std::string &file_name)
 
void WriteHistoImg (const std::string &file_name, CImg< FloatCHistogramPtr > *pHistoImg)
 
CImg< FloatCHistogramPtr > * ReadTextonHistoImg (const std::string &file_name)
 
CImg< FloatCHistogramPtr > * ReadColorHistoImg (const std::string &file_name)
 
void WriteTextonHistoImg (const std::string &file_name, CImg< FloatCHistogramPtr > *pHistoImg)
 
void WriteColorHistoImg (const std::string &file_name, CImg< FloatCHistogramPtr > *pHistoImg)
 
void PrepareHeatMap (kjb::Image &img, CImg< FloatCHistogramPtr > *pHistoImg, int padding, int x_position, int y_position)
 
double AngleDiff (double a1, double a2)
 
float AngleDiff (float a1, float a2)
 
double AngleSum (double a1, double a2)
 
float AngleSum (float a1, float a2)
 
float BiGauss (float mu1, float mu2, float mu12, float sigma1, float sigma2, float sigma12, float x1, float x2)
 
float FuzzySigmoid (float g, float a, float b, float c)
 
float Max (float *pBuf, int Size)
 
int Max (int *pBuf, int Size)
 
float Min (float *pBuf, int Size)
 
int iMin (float *pBuf, int Size)
 
double logbase (const double base, const double argument)
 
int NextPowerOfTwo (const int x)
 
void FloatToInt (const float &Xfloat, int &Xint, const float &MinRange, const float &MaxRange, const int &Resolution)
 
void IntToFloat (const int &Xint, float &Xfloat, const float &MinRange, const float &MaxRange, const int &Resolution)
 
bool IsAccute (const float &Theta)
 
float ParabolicInverseInterpolation (const float &x0, const float &y0, const float &x1, const float &y1, const float &x2, const float &y2)
 
void ParabolicOrientationInterpolation (const float &Theta1, const float &Rho1, const float &Theta2, const float &Rho2, const float &Theta3, const float &Rho3, float &InterpolatedThetaResult)
 
void ParabolicInterpolation (const float &x0, const float &y0, const float &x1, const float &y1, const float &x2, const float &y2, float &a, float &b, float &c)
 
void FixThetaRange (float &Theta, const bool &bHalfPhase=true)
 
template<class T >
void Swap (T &p1, T &p2)
 
template<class T >
SSD (const T &x1, const T &y1, const T &x2, const T &y2)
 
void WeberLaw (CImgVec< float > &InOutSeq, const float &WeberConst)
 

Typedef Documentation

TYPES.

typedef vector<CImg<BYTE>*>::iterator DTLib::ByteImgVecIter

TYPES.

typedef CImg<float>* DTLib::FloatCImgPtr
typedef vector<CImg<float>*>::iterator DTLib::FloatImgVecIter
typedef CImg< int > * DTLib::IntCImgPtr
typedef vector<CImg<int>*>::iterator DTLib::IntImgVecIter
typedef CImg<kjb_int32>* DTLib::LongCImgPtr
typedef CImgVec<kjb_int32>* DTLib::LongCImgVecPtr
typedef vector<CImg<kjb_int32>*>::iterator DTLib::LongImgVecIter

Function Documentation

double DTLib::AngleDiff ( double  a1,
double  a2 
)
float DTLib::AngleDiff ( float  a1,
float  a2 
)
double DTLib::AngleSum ( double  a1,
double  a2 
)
float DTLib::AngleSum ( float  a1,
float  a2 
)
void DTLib::BGR2Gray ( unsigned char *  pInBuf,
unsigned char *  pOutBuf,
const int &  Width,
const int &  Height 
)
void DTLib::BGR2L ( unsigned char *  pInBuf,
float *  pOutBuf,
const int &  Width,
const int &  Height,
const float &  Gamma = DEFAULT_GAMMA 
)
void DTLib::BGR2LAB ( float *  pInBuf,
float *  pOutBuf,
const int &  Width,
const int &  Height,
const float &  Gamma = DEFAULT_GAMMA 
)
void DTLib::BGR2Srg ( float *  pInBuf,
float *  pOutBuf,
const int &  Width,
const int &  Height 
)
float DTLib::BiGauss ( float  mu1,
float  mu2,
float  mu12,
float  sigma1,
float  sigma2,
float  sigma12,
float  x1,
float  x2 
)
int DTLib::CircumLength ( const int &  radius)
void DTLib::CombineScales ( CImgVec< BYTE > *  m_pNMSVec,
CImgVec< float > *  m_pEnergyVec,
CImgVec< float > *  m_pOriVec,
ByteCImgPtr *  m_pNMSCombImg,
FloatCImgPtr *  m_pOriCombImg,
FloatCImgPtr *  m_pEnergyCombImg,
int  m_InputWidth,
int  m_InputHeight,
int  m_nGaussScales 
)
void DTLib::CombineScalesNMSRhoTheta ( const int &  nGaussScales,
CImgVec< BYTE > &  InNMSVec,
CImgVec< float > &  InEnergyVec,
CImgVec< float > &  InOriVec,
CImg< BYTE > &  OutNMSCombImg,
CImg< float > &  OutEnergyCombImg,
CImg< float > &  OutOriCombImg 
)
void DTLib::Compute_All_Histograms ( const kjb::Image img,
CImg< FloatCHistogramPtr > **  m_pTextonHistoImg,
CImg< FloatCHistogramPtr > **  ColorHist 
)
void DTLib::Compute_Textons_Histograms ( const kjb::Image img,
CImg< FloatCHistogramPtr > **  m_pTextonHistoImg,
CImg< FloatCHistogramPtr > **  ColorHist,
FloatCImgPtr *  m_pDualHImg,
FloatCImgPtr *  m_pDualVImg,
ByteCImgPtr *  m_pSparsePatImg,
int  m_nGaussScales,
int  m_nGaussOrientations,
float  m_GaussSigmaY,
float  m_GaussX2YSigmaRatio,
int  m_nDOGScales,
float  m_DOGExcitSigma,
float  m_DOGInhibSigmaRatio1,
float  m_DOGInhibSigmaRatio2,
int  m_nCroppedPixels,
float  m_TextureWeberLawConst,
int  m_nTextureKMeansK,
int  m_nTextureKMeansIterations,
float  m_TextureMinDist,
float  m_TextureMaxDist,
float  m_TextureAlphaScaleFactor,
float  m_TextureDiskMiddleWidth,
float  m_TextureTau,
float  m_TextureBeta,
int  m_nBinsA,
int  m_nBinsB,
int  m_nBinsC,
float  m_ColorHistoSoftBinSigma,
float  m_EdgelLength,
float  m_InterveningContourSigma,
int  m_SparsePatternDenseRad,
int  m_SparsePatternMaxRad,
int  m_nSparsePatternSamples,
bool &  m_bColor 
)
DTLib::CCircleMasks * DTLib::ComputeCircleMasks ( int  m_minTextureScale,
int  m_maxTextureScale 
)
int * DTLib::ComputeCircum ( const int &  radius,
const int &  Width 
)
void DTLib::ComputeColorHistogramImg ( CCircleMasks pCircleMasks,
FloatCImgPtr  pTextureScaleImg,
FloatCImgPtr  pColorAImg,
FloatCImgPtr  pColorBImg,
CImg< FloatCHistogramPtr > *  pColorHistoImg,
LongCImgPtr  pPresegImg,
const float &  SoftUpdateSigma 
)
void DTLib::ComputeColorHistogramImg2Old ( CCircleMasks pCircleMasks,
FloatCImgPtr  pTextureScaleImg,
FloatCImgPtr  pColorAImg,
FloatCImgPtr  pColorBImg,
CImg< FloatCHistogramPtr > *  pColorHistoImg,
LongCImgPtr  pPresegImg,
const float &  SoftUpdateSigma 
)
void DTLib::ComputeColorHistogramImgBWNew ( CCircleMasks pCircleMasks,
FloatCImgPtr  pTextureScaleImg,
FloatCImgPtr  pColorAImg,
CImg< FloatCHistogramPtr > *  pColorHistoImg,
LongCImgPtr  pPresegImg,
const float &  SoftUpdateSigma 
)
void DTLib::ComputeColorHistogramImgNew ( CCircleMasks pCircleMasks,
FloatCImgPtr  pTextureScaleImg,
FloatCImgPtr  pColorAImg,
FloatCImgPtr  pColorBImg,
FloatCImgPtr  pColorCImg,
CImg< FloatCHistogramPtr > *  pColorHistoImg,
LongCImgPtr  pPresegImg,
const float &  SoftUpdateSigma 
)
void DTLib::ComputeColorHistoImg ( const kjb::Image img,
CImg< FloatCHistogramPtr > **  ColorHist,
int  m_nBinsA = 8,
int  m_nBinsB = 8,
int  m_nBinsC = 8,
float  m_ColorHistoSoftBinSigma = 1.8f,
int  m_nCroppedPixels = 10,
int  m_nGaussScales = 3,
int  m_nGaussOrientations = 12,
float  m_GaussSigmaY = 1.41f,
float  m_GaussX2YSigmaRatio = 3.0f,
int  m_nDOGScales = 3,
float  m_DOGExcitSigma = 1.41f,
float  m_DOGInhibSigmaRatio1 = 0.62f,
float  m_DOGInhibSigmaRatio2 = 1.6f,
float  m_TextureMinDist = 3.0f,
float  m_TextureMaxDist = 0.1f,
float  m_TextureAlphaScaleFactor = 1.5f,
float  m_TextureDiskMiddleWidth = 3.0f 
)
DTLib::CImg< DTLib::FloatCHistogramPtr > * DTLib::ComputeColorHistoImg ( FloatCImgPtr  m_pTextureScaleImg,
CCircleMasks *  m_pCircleMasks,
FloatCImgPtr  m_pAImg,
FloatCImgPtr  m_pBImg,
FloatCImgPtr  m_pCImg,
int  m_InputWidth,
int  m_InputHeight,
int  m_nBinsA,
int  m_nBinsB,
int  m_nBinsC,
float  m_ColorHistoSoftBinSigma,
bool  is_colour 
)
void DTLib::ComputeDualLattice ( CImgVec< float > *  m_pEnergyVec,
CImgVec< float > *  m_pOriVec,
CImgVec< BYTE > *  m_pNMSVec,
CImgVec< float > *  m_pXLocVec,
CImgVec< float > *  m_pYLocVec,
FloatCImgPtr  m_pPTextureImg,
FloatCImgPtr *  m_pDualHImg,
FloatCImgPtr *  m_pDualVImg,
int  m_InputWidth,
int  m_InputHeight,
int  m_nGaussScales,
float  m_EdgelLength,
float  m_InterveningContourSigma 
)
void DTLib::ComputeNonmaximaSuppression ( CFilterbank *  m_pFilterbank,
FloatCImgVecPtr  m_pOEVec,
CImgVec< BYTE > **  m_pNMSVec,
CImgVec< float > **  m_pEnergyVec,
CImgVec< float > **  m_pOriVec,
CImgVec< float > **  m_pXLocVec,
CImgVec< float > **  m_pYLocVec,
CImgVec< float > **  m_pErrVec,
int  m_nGaussScales,
int  m_nGaussOrientations,
int  m_InputWidth,
int  m_InputHeight 
)
void DTLib::ComputeOrientationEnergy ( FloatCImgPtr  m_pInputImage,
CFilterbank *  m_pFilterbank,
FloatCImgVecPtr  m_pConvVec,
FloatCImgVecPtr *  m_pOEVec,
int  m_nGaussScales,
int  m_nGaussOrientations 
)
DTLib::FloatCImgPtr DTLib::ComputePTexture ( DTLib::CCircleMasks m_pCircleMasks,
FloatCImgPtr  m_pTextureScaleImg,
LongCImgPtr  m_pTextonsImg,
ByteCImgPtr  m_pNMSCombImg,
FloatCImgPtr  m_pOriCombImg,
int  m_InputWidth,
int  m_InputHeight,
int  m_minTextureScale,
int  m_maxTextureScale,
int  m_nTextureKMeansK,
float  m_TextureDiskMiddleWidth,
float  m_TextureTau,
float  m_TextureBeta 
)
void DTLib::ComputePTextureImg ( CCircleMasks CircleMasks,
CImg< BYTE > &  NMSCombImg,
CImg< float > &  ThetaStarImg,
CImg< float > &  TextureScaleImg,
CImg< kjb_int32 > &  TextonMembershipImg,
const int &  K,
const float &  DiskMiddleBandThickness,
const float &  Tau,
const float &  Beta,
CImg< float > &  PTextureImg 
)
DTLib::ByteCImgPtr DTLib::ComputeSparsePattern ( int  m_SparsePatternDenseRad,
int  m_SparsePatternMaxRad,
int  m_nSparsePatternSamples 
)
void DTLib::ComputeTextonHistogramImg ( CCircleMasks *  pCircleMasks,
FloatCImgPtr  pTextureScaleImg,
CImg< kjb_int32 > *  pTextonsImg,
FloatCImgPtr  pPTextureImg,
CImg< FloatCHistogramPtr > *  pTextonHistoImg,
CImg< kjb_int32 > *  pPresegImg = NULL 
)
void DTLib::ComputeTextonHistoImg ( )
void DTLib::ComputeTextonHistoImg ( LongCImgPtr  m_pTextonsImg,
FloatCImgPtr  m_pTextureScaleImg,
FloatCImgPtr  m_pPTextureImg,
DTLib::CCircleMasks m_pCircleMasks,
CImg< FloatCHistogramPtr > **  m_pTextonHistoImg,
int  m_InputWidth,
int  m_InputHeight,
int  m_nTextureKMeansK 
)
DTLib::FloatCImgPtr DTLib::ComputeTextureScale ( LongCImgPtr  m_pTextonsImg,
CTextureScale **  m_pTS,
int  m_InputWidth,
int  m_InputHeight,
int  m_nTextureKMeansK,
float  m_TextureMinDist,
float  m_TextureMaxDist,
float  m_TextureAlphaScaleFactor,
int &  m_minTextureScale,
int &  m_maxTextureScale 
)
void DTLib::ComputeWeberLaw ( CFilterbank *  m_pFilterbank_ptr,
FloatCImgVecPtr  m_pConvVec_ptr,
float  m_TextureWeberLawConst 
)
DTLib::FloatCImgPtr DTLib::convert_kjb_to_CImg ( const kjb::Image img,
FloatCImgPtr *  m_pAImg,
FloatCImgPtr *  m_pBImg,
int  m_nCroppedPixels,
bool &  m_bColor 
)
float ** DTLib::convert_matrix ( float *  a,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
void DTLib::Convolve ( CImg< float > &  InImg,
CImg< float > &  KernelImg,
CImg< float > &  OutImg 
)
float ** DTLib::copy_mat ( float **  m,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
unsigned char * DTLib::cvector ( long  nl,
long  nh 
)
float ** DTLib::diag_matrix ( float  diagVal,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
void DTLib::diag_matrix_from_vec ( float *  v,
float **  m,
long  nl,
long  nh 
)
double ** DTLib::dmatrix ( long  nrl,
long  nrh,
long  ncl,
long  nch 
)
void DTLib::do_textons ( FloatCImgVecPtr  m_pConvVec,
LongCImgPtr *  m_pTextonsImg,
int  m_nGaussScales,
int  m_nGaussOrientations,
int  m_nDOGScales,
int  m_InputWidth,
int  m_InputHeight,
int  m_nTextureKMeansK,
int  m_nTextureKMeansIterations 
)
double * DTLib::dvector ( long  nl,
long  nh 
)
void DTLib::extract_texture ( const kjb::Image img,
const kjb::Int_matrix seg_map,
kjb::Matrix Oe_mean,
kjb::Matrix Oe_var,
kjb::Matrix DOG_mean,
kjb::Matrix DOG_var,
int  m_nGaussScales,
int  m_nGaussOrientations,
float  m_GaussSigmaY,
float  m_GaussX2YSigmaRatio,
int  m_nDOGScales,
float  m_DOGExcitSigma,
float  m_DOGInhibSigmaRatio1,
float  m_DOGInhibSigmaRatio2,
int  m_nCroppedPixels 
)
float *** DTLib::f3tensor ( long  nrl,
long  nrh,
long  ncl,
long  nch,
long  ndl,
long  ndh 
)
void DTLib::fft_free ( )
int DTLib::fftn ( int  ndim,
const int  dims[],
double  Re[],
double  Im[],
int  isign,
double  scaling 
)
int DTLib::fftnf ( int  ndim,
const int  dims[],
float  Re[],
float  Im[],
int  isign,
double  scaling 
)
void DTLib::FilterbankConvolve ( FloatCImgPtr  m_pInputImage,
CFilterbank **  m_pFilterbank_ptr,
FloatCImgVecPtr *  m_pConvVec_ptr,
int  m_nGaussScales,
int  m_nGaussOrientations,
float  m_GaussSigmaY,
float  m_GaussX2YSigmaRatio,
int  m_nDOGScales,
float  m_DOGExcitSigma,
float  m_DOGInhibSigmaRatio1,
float  m_DOGInhibSigmaRatio2 
)
void DTLib::FixThetaRange ( float &  Theta,
const bool &  bHalfPhase = true 
)
void DTLib::FloatToInt ( const float &  Xfloat,
int &  Xint,
const float &  MinRange,
const float &  MaxRange,
const int &  Resolution 
)
void DTLib::free_convert_matrix ( float **  b,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
void DTLib::free_cvector ( unsigned char *  v,
long  nl,
long  nh 
)
void DTLib::free_dmatrix ( double **  m,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
void DTLib::free_dvector ( double *  v,
long  nl,
long  nh 
)
void DTLib::free_f3tensor ( float ***  t,
long  nrl,
long  nrh,
long  ncl,
long  nch,
long  ndl,
long  ndh 
)
void DTLib::free_fvector ( float *  v,
long  nl,
long  nh 
)
void DTLib::free_imatrix ( int **  m,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
void DTLib::free_ivector ( int *  v,
long  nl,
long  nh 
)
void DTLib::free_lvector ( kjb_uint32 *  v,
long  nl,
long  nh 
)
void DTLib::free_matrix ( float **  m,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
void DTLib::free_submatrix ( float **  b,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
float DTLib::FuzzySigmoid ( float  g,
float  a,
float  b,
float  c 
)
float * DTLib::fvector ( long  nl,
long  nh 
)
void DTLib::FwdFFT ( float *  aRe,
float *  aIm,
const int  Size 
)
float DTLib::gasdev ( long *  idum)
void DTLib::GetSuccessiveOEThetaPairs ( CImgVec< float > &  OEVec,
const int &  nGaussOrientations,
const int &  iScale,
const int &  iTheta,
const int &  x,
const int &  y,
int &  iPrevTheta,
int &  iNextTheta,
float &  PrevTheta,
float &  Theta,
float &  NextTheta,
float &  PrevOE,
float &  OE,
float &  NextOE 
)
void DTLib::GetTextureFeatures ( int *  SegBuf,
int  Width,
int  Height,
int  nGaussScales,
int  nGaussOrientations,
CImgVec< float > &  OEVec,
CImgVec< float > &  ConvVec,
int  nDOGScales,
kjb::Matrix Oe_mean,
kjb::Matrix Oe_var,
kjb::Matrix DOG_mean,
kjb::Matrix DOG_var 
)
void DTLib::Hilbert ( float *  aInVector,
const int  Length 
)
int ** DTLib::imatrix ( long  nrl,
long  nrh,
long  ncl,
long  nch 
)
int DTLib::iMin ( float *  pBuf,
int  Size 
)
float DTLib::inner ( float *  x,
float *  y,
long  nl,
long  nh 
)
template<class T >
void DTLib::Interleaved2Planar ( T *  pIn,
T *  pOut1,
T *  pOut2,
T *  pOut3,
const int &  Width,
const int &  Height 
)
inline
void DTLib::InterpolateOrientations ( const int &  iScale,
const int &  nGaussOrientations,
CImgVec< float > &  OEVec,
CImgVec< BYTE > &  ThetaIdxVec,
CImgVec< float > &  ThetaVec 
)
void DTLib::IntToFloat ( const int &  Xint,
float &  Xfloat,
const float &  MinRange,
const float &  MaxRange,
const int &  Resolution 
)
void DTLib::InvFFT ( float *  aRe,
float *  aIm,
const int  Size 
)
bool DTLib::IsAccute ( const float &  Theta)
int * DTLib::ivector ( long  nl,
long  nh 
)
bool DTLib::LinesIntersect ( const int &  x1,
const int &  y1,
const int &  x2,
const int &  y2,
const int &  x3,
const int &  y3,
const int &  x4,
const int &  y4 
)
bool DTLib::LinesIntersect ( const float &  x1,
const float &  y1,
const float &  x2,
const float &  y2,
const float &  x3,
const float &  y3,
const float &  x4,
const float &  y4 
)
double DTLib::logbase ( const double  base,
const double  argument 
)
void DTLib::lubksb ( float **  a,
int  n,
int *  indx,
float *  b 
)
void DTLib::ludcmp ( float **  a,
int  n,
int *  indx,
float *  d 
)
kjb_uint32 * DTLib::lvector ( long  nl,
long  nh 
)
CImg< FloatCHistogramPtr > * DTLib::MakeBWEmptyColorHistoImg ( const int &  Width,
const int &  Height,
const int &  nAs,
const float &  minA,
const float &  maxA 
)
void DTLib::MakeDualLattice ( const float &  EdgelLength,
const float &  SigmaIC,
const int &  nGaussScales,
CImgVec< BYTE > &  InNMSVec,
CImgVec< float > &  InEnergyVec,
CImgVec< float > &  InOriVec,
CImgVec< float > &  InXLocVec,
CImgVec< float > &  InYLocVec,
CImg< float > &  InPTextureImg,
CImg< float > &  OutDualHImg,
CImg< float > &  OutDualVImg 
)
CImg< FloatCHistogramPtr > * DTLib::MakeEmptyColorHistoImg ( const int &  Width,
const int &  Height,
const int &  nAs,
const int &  nBs,
const int &  nCs,
const float &  minA,
const float &  maxA,
const float &  minB,
const float &  maxB,
const float &  minC,
const float &  maxC 
)
CImg< FloatCHistogramPtr > * DTLib::MakeEmptyTextonHistoImg ( const int &  Width,
const int &  Height,
const int &  K 
)
float * DTLib::mat_diag_fvector ( float **  mat,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
void DTLib::mat_inverse ( float **  m,
float **  res,
long  n 
)
void DTLib::mat_mat_diff ( float **  A,
float **  B,
float **  res,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
void DTLib::mat_mat_prod ( float **  A,
float **  B,
float **  res,
long  nrl,
long  nrh,
long  ncl,
long  nch,
long  ncl2,
long  nch2 
)
void DTLib::mat_mat_sum ( float **  A,
float **  B,
float **  res,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
void DTLib::mat_transpose ( float **  m1,
float **  mres,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
void DTLib::mat_vec_prod ( float **  A,
float *  x,
float *  y,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
int DTLib::MatlabTypeID ( float *  pBuffer)
inline
int DTLib::MatlabTypeID ( unsigned char *  pBuffer)
inline
int DTLib::MatlabTypeID ( int *  pBuffer)
inline
float ** DTLib::matrix ( long  nrl,
long  nrh,
long  ncl,
long  nch 
)
float DTLib::Max ( float *  pBuf,
int  Size 
)
int DTLib::Max ( int *  pBuf,
int  Size 
)
void DTLib::MedianFilter ( CImg< float > &  InImg,
CImg< float > &  OutImg,
const int &  Radius 
)
float DTLib::Min ( float *  pBuf,
int  Size 
)
int DTLib::NextPowerOfTwo ( const int  x)
void DTLib::nrerror ( char  error_text[])
void DTLib::OrientationEnergy ( const int &  nGaussScales,
const int &  nGaussOrientations,
CImgVec< float > &  ConvVec,
CImgVec< float > &  OEVec 
)
Parameters
OEVec/////////////////////////////////////////////////////////////////////////
void DTLib::ParabolicInterpolation ( const float &  x0,
const float &  y0,
const float &  x1,
const float &  y1,
const float &  x2,
const float &  y2,
float &  a,
float &  b,
float &  c 
)
float DTLib::ParabolicInverseInterpolation ( const float &  x0,
const float &  y0,
const float &  x1,
const float &  y1,
const float &  x2,
const float &  y2 
)
void DTLib::ParabolicOrientationInterpolation ( const float &  Theta1,
const float &  Rho1,
const float &  Theta2,
const float &  Rho2,
const float &  Theta3,
const float &  Rho3,
float &  InterpolatedThetaResult 
)
void DTLib::ParabolicOrientationsFit ( const int &  nGaussScales,
const int &  nGaussOrientations,
CImgVec< float > &  OEVec,
CImgVec< float > &  RhoVec,
CImgVec< float > &  ThetaVec,
CImgVec< BYTE > &  ThetaIdxVec 
)
void DTLib::PrepareHeatMap ( kjb::Image img,
CImg< FloatCHistogramPtr > *  pHistoImg,
int  padding,
int  x_position,
int  y_position 
)
float DTLib::ran1 ( long *  idum)
float ** DTLib::rand_matrix ( long  nrl,
long  nrh,
long  ncl,
long  nch 
)
template<class T >
T * DTLib::ReadBufferFromMatfile ( const char *  strFilename,
T *  pBuffer,
int &  Width,
int &  Height 
)
DTLib::CImg< DTLib::FloatCHistogramPtr > * DTLib::ReadColorHistoImg ( const std::string &  file_name)
DTLib::CImg< DTLib::FloatCHistogramPtr > * DTLib::ReadHistoImg ( const std::string &  file_name)
template<class T >
bool DTLib::ReadMatfile ( CImg< T > *  pInImg,
const char *  strFilename 
)
template<class T >
bool DTLib::ReadMatfile ( CImg< T > &  InImg,
const char *  strFilename 
)
template<class T >
bool DTLib::ReadMatfiles ( CImgVec< T > &  InVec,
const char *  strPrefix 
)
void DTLib::ReadMatheader ( const char *  strFilename)
DTLib::CImg< DTLib::FloatCHistogramPtr > * DTLib::ReadTextonHistoImg ( const std::string &  file_name)
template<class T >
void DTLib::Reflect ( CImg< T > &  InImg,
CImg< T > &  OutImg 
)
void DTLib::report_int ( const std::string &  msg,
int  value 
)
template<class T >
void DTLib::Rotate ( CImg< T > &  InImg,
CImg< T > &  OutImg,
const double &  Theta,
const T &  BGVal = 0 
)
void DTLib::scal_mat_prod ( float  s,
float **  m,
float **  res,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
void DTLib::scal_vec_prod ( float  s,
float *  v,
float *  res,
long  nl,
long  nh 
)
void DTLib::SeparateChannels ( CImg< kjb_int32 > &  InCombImg,
CImgVec< BYTE > &  OutChannelVec,
const kjb_int32 &  nSegments 
)
template<class T >
T DTLib::SSD ( const T &  x1,
const T &  y1,
const T &  x2,
const T &  y2 
)
inline
float ** DTLib::submatrix ( float **  a,
long  oldrl,
long  oldrh,
long  oldcl,
long  oldch,
long  newrl,
long  newcl 
)
void DTLib::SubpixelLocalization ( const int &  nGaussScales,
const int &  nGaussOrientations,
CImgVec< float > &  OESeq,
CImgVec< BYTE > &  ThetaIdxSeq,
CImgVec< BYTE > &  MaximaSeq,
CImgVec< float > &  RhoStarSeq,
CImgVec< float > &  ThetaSeq,
CImgVec< float > &  XLocSeq,
CImgVec< float > &  YLocSeq,
CImgVec< float > &  ErrSeq 
)
template<class T >
void DTLib::Swap ( T &  p1,
T &  p2 
)
inline
void DTLib::trace_mat ( float **  m,
long  nrl,
long  nrh,
long  ncl,
long  nch 
)
void DTLib::trace_vec ( float *  v,
long  nl,
long  nh 
)
void DTLib::vec_vec_assign ( float *  a,
float *  b,
long  nl,
long  nh 
)
void DTLib::vec_vec_diff ( float *  a,
float *  b,
float *  res,
long  nl,
long  nh 
)
void DTLib::vec_vec_prod ( float *  a,
float *  b,
float *  res,
long  nl,
long  nh 
)
void DTLib::vec_vec_sum ( float *  a,
float *  b,
float *  res,
long  nl,
long  nh 
)
void DTLib::WeberLaw ( CImgVec< float > &  InOutSeq,
const float &  WeberConst 
)
template<class T >
bool DTLib::WriteBufferToMatfile ( T *  pBuffer,
const int  Width,
const int  Height,
const char *  strMatName,
const char *  strFilename 
)
void DTLib::WriteColorHistoImg ( const std::string &  file_name,
CImg< FloatCHistogramPtr > *  pHistoImg 
)
void DTLib::WriteHistoImg ( const std::string &  file_name,
CImg< FloatCHistogramPtr > *  pHistoImg 
)
template<class T >
bool DTLib::WriteMatfile ( CImg< T > &  InImg,
const char *  strMatname,
const char *  strFilename 
)
template<class T >
bool DTLib::WriteMatfile ( CImg< T > &  InImg,
const char *  strMatname 
)
template<class T >
bool DTLib::WriteMatfiles ( CImgVec< T > &  InVec,
const char *  strPrefix 
)
template<class T >
bool DTLib::WriteMatfiles ( const vector< CImg< T > * > &  InVec,
const char *  strPrefix 
)
void DTLib::WriteTextonHistoImg ( const std::string &  file_name,
CImg< FloatCHistogramPtr > *  pHistoImg 
)
float * DTLib::zero_fvector ( long  nl,
long  nh 
)
float ** DTLib::zero_matrix ( long  nrl,
long  nrh,
long  ncl,
long  nch 
)