// Author: Ce Liu (c) Dec, 2009; celiu@mit.edu // Modified By: Deepak Pathak (c) 2016; pathak@berkeley.edu #pragma once #include "project.hpp" #include "stdio.h" #include "memory.h" #include "ImageProcessing.hpp" #include #include #include #include "Vector.hpp" #include "Stochastic.hpp" #ifndef _MATLAB #include "ImageIO.hpp" #else #include "mex.h" #endif using namespace std; enum collapse_type{collapse_average,collapse_max,collapse_min}; enum color_type{RGB,BGR,DATA,GRAY}; // template class for image template class Image { public: T* pData; protected: int imWidth,imHeight,nChannels; int nPixels,nElements; bool IsDerivativeImage; color_type colorType; public: Image(void); Image(int width,int height,int nchannels=1); Image(const T& value,int _width,int _height,int _nchannels=1); Image(const Image& other); ~Image(void); virtual Image& operator=(const Image& other); virtual inline void computeDimension(){nPixels=imWidth*imHeight;nElements=nPixels*nChannels;}; virtual void allocate(int width,int height,int nchannels=1); template void allocate(const Image& other); virtual void clear(); virtual void reset(); virtual void copyData(const Image& other); void setValue(const T& value); void setValue(const T& value,int _width,int _height,int _nchannels=1); T immax() const { T Max=pData[0]; for(int i=1;i void copy(const Image& other); void im2double(); // function to access the member variables inline const T& operator [] (int index) const {return pData[index];}; inline T& operator[](int index) {return pData[index];}; inline T*& data(){return pData;}; inline const T*& data() const{return (const T*&)pData;}; inline int width() const {return imWidth;}; inline int height() const {return imHeight;}; inline int nchannels() const {return nChannels;}; inline int npixels() const {return nPixels;}; inline int nelements() const {return nElements;}; inline bool isDerivativeImage() const {return IsDerivativeImage;}; inline color_type colortype() const{return colorType;}; void setColorType(int colorVal) { switch (colorVal) { case 1: colorType = GRAY; break; default: colorType = RGB; } return; } bool IsFloat () const; bool IsEmpty() const {if(nElements==0) return true;else return false;}; bool IsInImage(int x,int y) const {if(x>=0 && x=0 && y bool matchDimension (const Image& image) const; bool matchDimension (int width,int height,int nchannels) const; inline void setDerivative(bool isDerivativeImage=true){IsDerivativeImage=isDerivativeImage;}; bool BoundaryCheck() const; // function to move this image to another one template void moveto(Image& image,int x,int y,int width=0,int height=0); // function of basic image operations virtual bool imresize(double ratio); template void imresize(Image& result,double ratio) const; void imresize(int dstWidth,int dstHeight); template void imresize(Image& result,int dstWidth,int dstHeight) const; template void upSampleNN(Image& result,int ratio) const; // image IO's virtual bool saveImage(const char* filename) const; virtual bool loadImage(const char* filename); virtual bool saveImage(ofstream& myfile) const; virtual bool loadImage(ifstream& myfile); // #ifndef _MATLAB // virtual bool imread(const char* filename); // virtual bool imwrite(const char* filename) const; // virtual bool imwrite(const char* filename,ImageIO::ImageType) const; // //virtual bool imread(const QString& filename); // //virtual void imread(const QImage& image); // // //virtual bool imwrite(const QString& filename,int quality=100) const; // //virtual bool imwrite(const QString& filename,ImageIO::ImageType imagetype,int quality=100) const; // //virtual bool imwrite(const QString& fileanme,T min,T max,int quality=100) const; // #else // virtual bool imread(const char* filename) const {return true;}; // virtual bool imwrite(const char* filename) const {return true;}; // #endif template Image dx (bool IsAdvancedFilter=false) const; template void dx(Image& image,bool IsAdvancedFilter=false) const; template Image dy(bool IsAdvancedFilter=false) const; template void dy(Image& image,bool IsAdvancedFilter=false) const; template void dxx(Image& image) const; template void dyy(Image& image) const; template void laplacian(Image& image) const; template void gradientmag(Image& image) const; void GaussianSmoothing(double sigma,int fsize); template void GaussianSmoothing(Image& image,double sigma,int fsize) const; template void GaussianSmoothing_transpose(Image& image,double sigma,int fsize) const; template void smoothing(Image& image,double factor=4); template Image smoothing(double factor=4); void smoothing(double factor=4); // funciton for filtering template void imfilter(Image& image,const double* filter,int fsize) const; template void imfilter(Image& image,const Image& kernel) const; template Image imfilter(const double* filter,int fsize) const; template void imfilter_h(Image& image,double* filter,int fsize) const; template void imfilter_v(Image& image,double* filter,int fsize) const; template void imfilter_hv(Image& image,const double* hfilter,int hfsize,const double* vfilter,int vfsize) const; template void imfilter_hv(Image& image,const Image& hfilter,const Image& vfilter) const; // funciton for filtering transpose template void imfilter_transpose(Image& image,const double* filter,int fsize) const; template void imfilter_transpose(Image& image,const Image& kernel) const; template Image imfilter_transpose(const double* filter,int fsize) const; template void imfilter_h_transpose(Image& image,double* filter,int fsize) const; template void imfilter_v_transpose(Image& image,double* filter,int fsize) const; template void imfilter_hv_transpose(Image& image,const double* hfilter,int hfsize,const double* vfilter,int vfsize) const; template void imfilter_hv_transpose(Image& image,const Image& hfilter,const Image& vfilter) const; // function to desaturating template void desaturate(Image& image) const; void desaturate(); template void collapse(Image& image,collapse_type type = collapse_average) const; void collapse(collapse_type type = collapse_average); void flip_horizontal(Image& image); void flip_horizontal(); // function to concatenate images template void concatenate(Image& destImage,const Image& addImage) const; template void concatenate(Image& destImage,const Image& addImage,double ratio) const; template Image concatenate(const Image& addImage) const; // function to separate the channels of the image template void separate(unsigned firstNChannels,Image& image1,Image& image2) const; // function to sample patch template void getPatch(Image& patch,double x,double y,int fsize) const; // function to crop the image template void crop(Image& patch,int Left,int Top,int Width,int Height) const; // basic numerics of images template void Multiply(const Image& image1,const Image& image2); template void MultiplyAcross(const Image& image1,const Image& image2); template void Multiply(const Image& image1,const Image& image2,const Image& image3); template void Multiplywith(const Image& image1); template void MultiplywithAcross(const Image& image1); void Multiplywith(double value); template void Add(const Image& image1,const Image& image2); template void Add(const Image& image1,const Image& image2,double ratio); void Add(const T value); template void Add(const Image& image1,const double value); template void Add(const Image& image1); template void Subtract(const Image& image1,const Image& image2); // arestmetic operators void square(); // exp void Exp(double sigma = 1); // function to normalize an image void normalize(Image& image); // function to threshold an image void threshold(); // function to compute the statistics of the image double norm2() const; double sum() const; template double innerproduct(Image& image) const; // function to bilateral smooth flow field template void BilateralFiltering(Image& other,int fsize,double filter_signa,double range_sigma); // function to bilateral smooth an image //Image BilateralFiltering(int fsize,double filter_sigma,double range_sigma); void imBilateralFiltering(Image& result,int fsize,double filter_sigma,double range_sigma); template int kmeansIndex(int pixelIndex,T1& minDistance,const T2* pDictionary,int nVocabulary, int nDim); // convert an image into visual words based on a dictionary template void ConvertToVisualWords(Image& result,const T2* pDictionary,int nDim,int nVocabulary); // get the histogram of an image region // the range is [0,imWidth] (x) and [0,imHeight] (y) template Vector histogramRegion(int nBins,double left,double top,double right,double bottom) const; // function for bicubic image interpolation template inline void BicubicCoeff(double a[][4],const T* pIm,const T1* pImDx,const T1* pImDy,const T1* pImDxDy,const int offsets[][2]) const; template void warpImageBicubic(Image& output,const Image& imdx,const Image& imdy, const Image& imdxdy,const Image& vx,const Image& vy) const; template void warpImageBicubic(Image& output,const Image& vx,const Image& vy) const; template void warpImageBicubicCoeff(Image& Coeff) const; template void warpImageBicubic(Image& output,const Image& coeff,const Image& vx,const Image& vy) const; template void warpImageBicubicRef(const Image& ref,Image& output,const Image& imdx,const Image& imdy, const Image& imdxdy,const Image& vx,const Image& vy) const; template void warpImageBicubicRef(const Image& ref,Image& output,const Image& vx,const Image& vy) const; template void warpImageBicubicRef(const Image& ref,Image& output,const Image& coeff,const Image& vx,const Image& vy) const; template void warpImageBicubicRef(const Image& ref,Image& output,const Image& flow) const; template void DissembleFlow(Image& vx,Image& vy) const; // function for image warping template void warpImage(Image& output,const Image& vx,const Image& vy) const; // function for image warping transpose template void warpImage_transpose(Image& output,const Image& vx,const Image& vy) const; // function for image warping template void warpImage(Image& output,const Image& flow) const; // function for image warping transpose template void warpImage_transpose(Image& output,const Image& flow) const; // function to get the max T max() const; // function to get min T min() const; void generate2DGuasisan(int winsize,double sigma) { clear(); imWidth = imHeight = winsize*2+1; nChannels = 1; computeDimension(); ImageProcessing::generate2DGaussian(pData,winsize,sigma); } void generate1DGaussian(int winsize,double sigma) { clear(); imWidth = winsize*2+1; imHeight = 1; nChannels = 1; computeDimension(); ImageProcessing::generate1DGaussian(pData,winsize,sigma); } template void subSampleKernelBy2(Image& output) const { int winsize = (imWidth-1)/2; int winsize_s = winsize/2; int winlen_s = winsize_s*2+1; if(!output.matchDimension(winlen_s,1,1)) output.allocate(winlen_s,1,1); output.pData[winsize_s] = pData[winsize]; for(int i = 0;i void LoadMatlabImageCore(const mxArray* image,bool IsImageScaleCovnersion=true); template void ConvertFromMatlab(const T1* pMatlabPlane,int _width,int _height,int _nchannels); void OutputToMatlab(mxArray*& matrix) const; template void ConvertToMatlab(T1* pMatlabPlane) const; #endif }; typedef Image BiImage; typedef Image UCImage; typedef Image IntImage; typedef Image FImage; typedef Image DImage; //------------------------------------------------------------------------------------------ // constructor //------------------------------------------------------------------------------------------ template Image::Image() { pData=NULL; imWidth=imHeight=nChannels=nPixels=nElements=0; colorType=RGB; IsDerivativeImage=false; } //------------------------------------------------------------------------------------------ // constructor with specified dimensions //------------------------------------------------------------------------------------------ template Image::Image(int width,int height,int nchannels) { imWidth=width; imHeight=height; nChannels=nchannels; computeDimension(); pData=NULL; pData=new T[nElements]; if(nElements>0) memset(pData,0,sizeof(T)*nElements); IsDerivativeImage=false; } template Image::Image(const T& value,int _width,int _height,int _nchannels) { pData=NULL; allocate(_width,_height,_nchannels); setValue(value); } #ifndef _MATLAB //template //Image::Image(const QImage& image) //{ // pData=NULL; // imread(image); //} #endif template void Image::allocate(int width,int height,int nchannels) { clear(); imWidth=width; imHeight=height; nChannels=nchannels; computeDimension(); pData=NULL; if(nElements>0) { pData=new T[nElements]; memset(pData,0,sizeof(T)*nElements); } } template template void Image::allocate(const Image &other) { allocate(other.width(),other.height(),other.nchannels()); IsDerivativeImage = other.isDerivativeImage(); colorType = other.colortype(); } //------------------------------------------------------------------------------------------ // copy constructor //------------------------------------------------------------------------------------------ template Image::Image(const Image& other) { imWidth=imHeight=nChannels=nElements=0; pData=NULL; copyData(other); } //------------------------------------------------------------------------------------------ // destructor //------------------------------------------------------------------------------------------ template Image::~Image() { if(pData!=NULL) delete []pData; } //------------------------------------------------------------------------------------------ // clear the image //------------------------------------------------------------------------------------------ template void Image::clear() { if(pData!=NULL) delete []pData; pData=NULL; imWidth=imHeight=nChannels=nPixels=nElements=0; } //------------------------------------------------------------------------------------------ // reset the image (reset the buffer to zero) //------------------------------------------------------------------------------------------ template void Image::reset() { if(pData!=NULL) memset(pData,0,sizeof(T)*nElements); } template void Image::setValue(const T &value) { for(int i=0;i void Image::setValue(const T& value,int _width,int _height,int _nchannels) { if(imWidth!=_width || imHeight!=_height || nChannels!=_nchannels) allocate(_width,_height,_nchannels); setValue(value); } //------------------------------------------------------------------------------------------ // copy from other image //------------------------------------------------------------------------------------------ template void Image::copyData(const Image& other) { imWidth=other.imWidth; imHeight=other.imHeight; nChannels=other.nChannels; nPixels=other.nPixels; IsDerivativeImage=other.IsDerivativeImage; colorType = other.colorType; if(nElements!=other.nElements) { nElements=other.nElements; if(pData!=NULL) delete []pData; pData=NULL; pData=new T[nElements]; } if(nElements>0) memcpy(pData,other.pData,sizeof(T)*nElements); } template template void Image::copy(const Image& other) { clear(); imWidth=other.width(); imHeight=other.height(); nChannels=other.nchannels(); computeDimension(); IsDerivativeImage=other.isDerivativeImage(); colorType = other.colortype(); pData=NULL; pData=new T[nElements]; const T1*& srcData=other.data(); for(int i=0;i void Image::im2double() { if(IsFloat()) for(int i=0;i Image& Image::operator=(const Image& other) { copyData(other); return *this; } template bool Image::IsFloat() const { if(typeid(T)==typeid(float) || typeid(T)==typeid(double) || typeid(T)==typeid(long double)) return true; else return false; } template template bool Image::matchDimension(const Image& image) const { if(imWidth==image.width() && imHeight==image.height() && nChannels==image.nchannels()) return true; else return false; } template bool Image::matchDimension(int width, int height, int nchannels) const { if(imWidth==width && imHeight==height && nChannels==nchannels) return true; else return false; } //------------------------------------------------------------------------------------------ // function to move this image to a dest image at (x,y) with specified width and height //------------------------------------------------------------------------------------------ template template void Image::moveto(Image& image,int x0,int y0,int width,int height) { if(width==0) width=imWidth; if(height==0) height=imHeight; int NChannels=__min(nChannels,image.nchannels()); int x,y; for(int i=0;i=image.height()) break; for(int j=0;j=image.width()) break; for(int k=0;k bool Image::imresize(double ratio) { if(pData==NULL) return false; T* pDstData; int DstWidth,DstHeight; DstWidth=(double)imWidth*ratio; DstHeight=(double)imHeight*ratio; pDstData=new T[DstWidth*DstHeight*nChannels]; ImageProcessing::ResizeImage(pData,pDstData,imWidth,imHeight,nChannels,ratio); delete []pData; pData=pDstData; imWidth=DstWidth; imHeight=DstHeight; computeDimension(); return true; } template template void Image::imresize(Image& result,double ratio) const { int DstWidth,DstHeight; DstWidth=(double)imWidth*ratio; DstHeight=(double)imHeight*ratio; if(result.width()!=DstWidth || result.height()!=DstHeight || result.nchannels()!=nChannels) result.allocate(DstWidth,DstHeight,nChannels); else result.reset(); ImageProcessing::ResizeImage(pData,result.data(),imWidth,imHeight,nChannels,ratio); } template template void Image::imresize(Image& result,int DstWidth,int DstHeight) const { if(result.width()!=DstWidth || result.height()!=DstHeight || result.nchannels()!=nChannels) result.allocate(DstWidth,DstHeight,nChannels); else result.reset(); ImageProcessing::ResizeImage(pData,result.data(),imWidth,imHeight,nChannels,DstWidth,DstHeight); } template void Image::imresize(int dstWidth,int dstHeight) { DImage foo(dstWidth,dstHeight,nChannels); ImageProcessing::ResizeImage(pData,foo.data(),imWidth,imHeight,nChannels,dstWidth,dstHeight); copyData(foo); } template template void Image::upSampleNN(Image& output,int ratio) const { int width = imWidth*ratio; int height = imHeight*ratio; if(!output.matchDimension(width,height,nChannels)) output.allocate(width,height,nChannels); for(int i = 0; i bool Image::saveImage(const char *filename) const { ofstream myfile(filename,ios::out | ios::binary); if(myfile.is_open()) { bool foo = saveImage(myfile); myfile.close(); return foo; } else return false; } template bool Image::saveImage(ofstream& myfile) const { char type[16]; sprintf(type,"%s",typeid(T).name()); myfile.write(type,16); myfile.write((char *)&imWidth,sizeof(int)); myfile.write((char *)&imHeight,sizeof(int)); myfile.write((char *)&nChannels,sizeof(int)); myfile.write((char *)&IsDerivativeImage,sizeof(bool)); myfile.write((char *)pData,sizeof(T)*nElements); return true; } template bool Image::loadImage(const char *filename) { ifstream myfile(filename, ios::in | ios::binary); if(myfile.is_open()) { bool foo = loadImage(myfile); myfile.close(); return foo; } else return false; } template bool Image::loadImage(ifstream& myfile) { char type[16]; myfile.read(type,16); #ifdef _LINUX_MAC if(strcasecmp(type,"uint16")==0) sprintf(type,"unsigned short"); if(strcasecmp(type,"uint32")==0) sprintf(type,"unsigned int"); if(strcasecmp(type,typeid(T).name())!=0) { cout<<"The type of the image is different from the type of the object!"< // bool Image::imread(const char* filename) // { // clear(); // if(ImageIO::loadImage(filename,pData,imWidth,imHeight,nChannels)) // { // computeDimension(); // colorType = BGR; // when we use qt or opencv to load the image, it's often BGR // return true; // } // return false; // } //template //bool Image::imread(const QString &filename) //{ // clear(); // if(ImageIO::loadImage(filename,pData,imWidth,imHeight,nChannels)) // { // computeDimension(); // return true; // } // return false; //} // //template //void Image::imread(const QImage& image) //{ // clear(); // ImageIO::loadImage(image,pData,imWidth,imHeight,nChannels); // computeDimension(); //} // //------------------------------------------------------------------------------------------ // function to write the image //------------------------------------------------------------------------------------------ // template // bool Image::imwrite(const char* filename) const // { // // ImageIO::ImageType type; // if(IsDerivativeImage) // type=ImageIO::derivative; // else // type=ImageIO::standard; // return ImageIO::saveImage(filename,pData,imWidth,imHeight,nChannels,type); // } // template // bool Image::imwrite(const char* filename,ImageIO::ImageType type) const // { // return ImageIO::saveImage(filename,pData,imWidth,imHeight,nChannels,type); // } //template //bool Image::imwrite(const QString &filename, ImageIO::ImageType imagetype, int quality) const //{ // return ImageIO::writeImage(filename,(const T*&)pData,imWidth,imHeight,nChannels,imagetype,quality); //} // //template //bool Image::imwrite(const QString &filename, T min, T max, int quality) const //{ // return ImageIO::writeImage(filename,(const T*&)pData,imWidth,imHeight,nChannels,min,max,quality); //} #endif //------------------------------------------------------------------------------------------ // function to get x-derivative of the image //------------------------------------------------------------------------------------------ template template void Image::dx(Image& result,bool IsAdvancedFilter) const { if(matchDimension(result)==false) result.allocate(imWidth,imHeight,nChannels); result.reset(); result.setDerivative(); T1*& data=result.data(); int i,j,k,offset; if(IsAdvancedFilter==false) for(i=0;i template Image Image::dx(bool IsAdvancedFilter) const { Image result; dx(result,IsAdvancedFilter); return result; } //------------------------------------------------------------------------------------------ // function to get y-derivative of the image //------------------------------------------------------------------------------------------ template template void Image::dy(Image& result,bool IsAdvancedFilter) const { if(matchDimension(result)==false) result.allocate(imWidth,imHeight,nChannels); result.setDerivative(); T1*& data=result.data(); int i,j,k,offset; if(IsAdvancedFilter==false) for(i=0;i template Image Image::dy(bool IsAdvancedFilter) const { Image result; dy(result,IsAdvancedFilter); return result; } //------------------------------------------------------------------------------------------ // function to compute the second order derivative //------------------------------------------------------------------------------------------ template template void Image::dxx(Image &image) const { if(!matchDimension(image)) image.allocate(imWidth,imHeight,nChannels); T1* pDstData=image.data(); if(nChannels==1) // if there is only one image channel for(int i=0;i template void Image::dyy(Image& image) const { if(!matchDimension(image)) image.allocate(imWidth,imHeight,nChannels); T1* pDstData=image.data(); if(nChannels==1) for(int i=0;i template void Image::laplacian(Image &image) const { if(!matchDimension(image)) image.allocate(*this); image.setDerivative(true); ImageProcessing::Laplacian(pData,image.data(),imWidth,imHeight,nChannels); } //------------------------------------------------------------------------------------------ // function to compute the gradient magnitude of the image //------------------------------------------------------------------------------------------ template template void Image::gradientmag(Image &image) const { if(image.width()!=imWidth || image.height()!=imHeight) image.allocate(imWidth,imHeight); DImage Ix,Iy; dx(Ix,true); dy(Iy,true); double temp; double* imagedata=image.data(); const double *Ixdata=Ix.data(),*Iydata=Iy.data(); for(int i=0;i void Image::GaussianSmoothing(double sigma,int fsize) { Image foo; GaussianSmoothing(foo,sigma,fsize); copy(foo); } template template void Image::GaussianSmoothing(Image& image,double sigma,int fsize) const { Image foo; // constructing the 1D gaussian filter double* gFilter; gFilter=new double[fsize*2+1]; double sum=0; sigma=sigma*sigma*2; for(int i=-fsize;i<=fsize;i++) { gFilter[i+fsize]=exp(-(double)(i*i)/sigma); sum+=gFilter[i+fsize]; } for(int i=0;i<2*fsize+1;i++) gFilter[i]/=sum; // apply filtering imfilter_hv(image,gFilter,fsize,gFilter,fsize); delete[] gFilter; } //------------------------------------------------------------------------------------------ // function to do Gaussian smoothing //------------------------------------------------------------------------------------------ template template void Image::GaussianSmoothing_transpose(Image& image,double sigma,int fsize) const { Image foo; // constructing the 1D gaussian filter double* gFilter; gFilter=new double[fsize*2+1]; double sum=0; sigma=sigma*sigma*2; for(int i=-fsize;i<=fsize;i++) { gFilter[i+fsize]=exp(-(double)(i*i)/sigma); sum+=gFilter[i+fsize]; } for(int i=0;i<2*fsize+1;i++) gFilter[i]/=sum; // apply filtering imfilter_hv_transpose(image,gFilter,fsize,gFilter,fsize); delete[] gFilter; } //------------------------------------------------------------------------------------------ // function to smooth the image using a simple 3x3 filter // the filter is [1 factor 1]/(factor+2), applied horizontally and vertically //------------------------------------------------------------------------------------------ template template void Image::smoothing(Image& image,double factor) { // build double filter2D[9]={1,0,1,0, 0, 0,1, 0,1}; filter2D[1]=filter2D[3]=filter2D[5]=filter2D[7]=factor; filter2D[4]=factor*factor; for(int i=0;i<9;i++) filter2D[i]/=(factor+2)*(factor+2); if(matchDimension(image)==false) image.allocate(imWidth,imHeight,nChannels); imfilter(image,filter2D,1); } template template Image Image::smoothing(double factor) { Image result; smoothing(result,factor); return result; } template void Image::smoothing(double factor) { Image result(imWidth,imHeight,nChannels); smoothing(result,factor); copyData(result); } //------------------------------------------------------------------------------------------ // function of image filtering //------------------------------------------------------------------------------------------ template template void Image::imfilter(Image& image,const double* filter,int fsize) const { if(matchDimension(image)==false) image.allocate(imWidth,imHeight,nChannels); ImageProcessing::filtering(pData,image.data(),imWidth,imHeight,nChannels,filter,fsize); } template template void Image::imfilter(Image& image,const Image& kernel) const { if(kernel.width()!=kernel.height()) { cout<<"Error in Image::imfilter(Image& image,const Image& kernel)"< template Image Image::imfilter(const double *filter, int fsize) const { Image result; imfilter(result,filter,fsize); return result; } template template void Image::imfilter_h(Image& image,double* filter,int fsize) const { if(matchDimension(image)==false) image.allocate(imWidth,imHeight,nChannels); ImageProcessing::hfiltering(pData,image.data(),imWidth,imHeight,nChannels,filter,fsize); } template template void Image::imfilter_v(Image& image,double* filter,int fsize) const { if(matchDimension(image)==false) image.allocate(imWidth,imHeight,nChannels); ImageProcessing::vfiltering(pData,image.data(),imWidth,imHeight,nChannels,filter,fsize); } template template void Image::imfilter_hv(Image &image, const double *hfilter, int hfsize, const double *vfilter, int vfsize) const { if(matchDimension(image)==false) image.allocate(imWidth,imHeight,nChannels); T1* pTempBuffer; pTempBuffer=new T1[nElements]; ImageProcessing::hfiltering(pData,pTempBuffer,imWidth,imHeight,nChannels,hfilter,hfsize); ImageProcessing::vfiltering(pTempBuffer,image.data(),imWidth,imHeight,nChannels,vfilter,vfsize); delete[] pTempBuffer; } template template void Image::imfilter_hv(Image& image,const Image& hfilter,const Image& vfilter) const { int hfsize = (__max(hfilter.width(),hfilter.height())-1)/2; int vfsize = (__max(vfilter.width(),vfilter.height())-1)/2; imfilter_hv(image,hfilter.data(),hfsize,vfilter.data(),vfsize); } template bool Image