Add files using upload-large-folder tool

UVDoc_official/eval/eval_code/SIFTflow/SIFTflowc2f.m

@@ -0,0 +1,180 @@
+% function to do coarse to fine SIFT flow matching
+function [vx,vy,energylist]=SIFTflowc2f(im1,im2,SIFTflowpara,isdisplay,Segmentation)
+
+if isfield(SIFTflowpara,'alpha')
+    alpha=SIFTflowpara.alpha;
+else
+    alpha=0.01;
+end
+
+if isfield(SIFTflowpara,'d')
+    d=SIFTflowpara.d;
+else
+    d=alpha*20;
+end
+
+if isfield(SIFTflowpara,'gamma')
+    gamma=SIFTflowpara.gamma;
+else
+    gamma=0.001;
+end
+
+if isfield(SIFTflowpara,'nlevels')
+    nlevels=SIFTflowpara.nlevels;
+else
+    nlevels=4;
+end
+
+if isfield(SIFTflowpara,'wsize')
+    wsize=SIFTflowpara.wsize;
+else
+    wsize=3;
+end
+
+if isfield(SIFTflowpara,'topwsize')
+    topwsize=SIFTflowpara.topwsize;
+else
+    topwsize=10;
+end
+
+if isfield(SIFTflowpara,'nIterations')
+    nIterations=SIFTflowpara.nIterations;
+else
+    nIterations=40;
+end
+
+if isfield(SIFTflowpara,'nTopIterations')
+    nTopIterations=SIFTflowpara.nTopIterations;
+else
+    nTopIterations=100;
+end
+
+if exist('isdisplay','var')~=1
+    isdisplay=false;
+end
+
+if exist('Segmentation','var')==1
+    IsSegmentation=true;
+else
+    IsSegmentation=false;
+end
+
+% build the pyramid
+pyrd(1).im1=im1;
+pyrd(1).im2=im2;
+if IsSegmentation
+    pyrd(1).seg=Segmentation;
+end
+
+for i=2:nlevels
+    pyrd(i).im1=imresize(imfilter(pyrd(i-1).im1,fspecial('gaussian',5,0.67),'same','replicate'),0.5,'bicubic');
+    pyrd(i).im2=imresize(imfilter(pyrd(i-1).im2,fspecial('gaussian',5,0.67),'same','replicate'),0.5,'bicubic');
+%     pyrd(i).im1 = reduceImage(pyrd(i-1).im1);
+%     pyrd(i).im2 = reduceImage(pyrd(i-1).im2);
+    if IsSegmentation
+        pyrd(i).seg=imresize(pyrd(i-1).seg,0.5,'nearest');
+    end
+end
+
+for i=1:nlevels
+    [height,width,nchannels]=size(pyrd(i).im1);
+    [height2,width2,nchannels]=size(pyrd(i).im2);
+    [xx,yy]=meshgrid(1:width,1:height);    
+    pyrd(i).xx=round((xx-1)*(width2-1)/(width-1)+1-xx);
+    pyrd(i).yy=round((yy-1)*(height2-1)/(height-1)+1-yy);
+end
+
+nIterationArray=round(linspace(nIterations,nIterations,nlevels));
+
+for i=nlevels:-1:1
+    if isdisplay
+        fprintf('Level: %d...',i);
+    end
+    [height,width,nchannels]=size(pyrd(i).im1);
+    [height2,width2,nchannels]=size(pyrd(i).im2);
+    [xx,yy]=meshgrid(1:width,1:height);
+    
+    if i==nlevels
+%         vx=zeros(height,width);
+%         vy=vx;
+        vx=pyrd(i).xx;
+        vy=pyrd(i).yy;
+        
+        winSizeX=ones(height,width)*topwsize;
+        winSizeY=ones(height,width)*topwsize;
+    else
+%         vx=imresize(vx-pyrd(i+1).xx,[height,width],'bicubic')*2+pyrd(i).xx;
+%         vy=imresize(vy-pyrd(i+1).yy,[height,width],'bicubic')*2+pyrd(i).yy;
+        
+%         winSizeX=decideWinSize(vx,wsize);
+%         winSizeY=decideWinSize(vy,wsize);
+        vx=round(pyrd(i).xx+imresize(vx-pyrd(i+1).xx,[height,width],'bicubic')*2);
+        vy=round(pyrd(i).yy+imresize(vy-pyrd(i+1).yy,[height,width],'bicubic')*2);
+        
+        winSizeX=ones(height,width)*(wsize+i-1);
+        winSizeY=ones(height,width)*(wsize+i-1);
+    end
+    if nchannels<=3
+        Im1=im2feature(pyrd(i).im1);
+        Im2=im2feature(pyrd(i).im2);
+    else
+        Im1=pyrd(i).im1;
+        Im2=pyrd(i).im2;
+    end
+    % compute the image-based coefficient
+    if IsSegmentation
+        imdiff=zeros(height,width,2);
+        imdiff(:,1:end-1,1)=double(pyrd(i).seg(:,1:end-1)==pyrd(i).seg(:,2:end));
+        imdiff(1:end-1,:,2)=double(pyrd(i).seg(1:end-1,:)==pyrd(i).seg(2:end,:));
+        Im_s=imdiff*alpha+(1-imdiff)*alpha*0.01;
+        Im_d=imdiff*alpha*100+(1-imdiff)*alpha*0.01*20;
+    end
+    if i==nlevels
+        if IsSegmentation
+            [flow,foo]=mexDiscreteFlow(Im1,Im2,[alpha,d,gamma*2^(i-1),nTopIterations,2,topwsize],vx,vy,winSizeX,winSizeY,Im_s,Im_d);
+        else
+            [flow,foo]=mexDiscreteFlow(Im1,Im2,[alpha,d,gamma*2^(i-1),nTopIterations,2,topwsize],vx,vy,winSizeX,winSizeY);
+            %[flow,foo]=mexDiscreteFlow(Im1,Im2,[alpha,d,gamma*2^(i-1),nTopIterations,0,topwsize],vx,vy,winSizeX,winSizeY);
+        end
+%         [flow1,foo1]=mexDiscreteFlow(Im1,Im2,[alpha,d,gamma*2^(i-1),nIterationArray(i),0,topwsize],vx,vy,winSizeX,winSizeY);
+%         [flow2,foo2]=mexDiscreteFlow(Im1,Im2,[alpha,d,gamma*2^(i-1),nTopIterations,2,topwsize],vx,vy,winSizeX,winSizeY);
+%         if foo1(end)<foo2(end)
+%             flow=flow1;
+%             foo=foo1;
+%         else
+%             flow=flow2;
+%             foo=foo2;
+%         end
+    else
+        %[flow,foo]=mexDiscreteFlow(Im1,Im2,[alpha,d,gamma*2^(i-1),nIterations,nlevels-i,wsize],vx,vy,winSizeX,winSizeY);
+        if IsSegmentation
+            [flow,foo]=mexDiscreteFlow(Im1,Im2,[alpha,d,gamma*2^(i-1),nIterationArray(i),nlevels-i,wsize],vx,vy,winSizeX,winSizeY,Im_s,Im_d);
+        else
+            [flow,foo]=mexDiscreteFlow(Im1,Im2,[alpha,d,gamma*2^(i-1),nIterationArray(i),nlevels-i,wsize],vx,vy,winSizeX,winSizeY);
+            %[flow,foo]=mexDiscreteFlow(Im1,Im2,[alpha,d,gamma*2^(i-1),nIterationArray(i),0,wsize],vx,vy,winSizeX,winSizeY);
+        end
+%         [flow,foo]=mexDiscreteFlow(Im1,Im2,[alpha,d,gamma*2^(i-1),nIterationArray(i),0,wsize],vx,vy,winSizeX,winSizeY);
+    end
+    energylist(i).data=foo;
+    vx=flow(:,:,1);
+    vy=flow(:,:,2);
+    if isdisplay
+        fprintf('done!\n');
+    end
+end
+
+function winSizeIm=decideWinSize(offset,wsize)
+
+% design the DOG filter
+f1=fspecial('gaussian',9,1);
+f2=fspecial('gaussian',9,.5);
+f=f2-f1;
+
+foo=imfilter(abs(imfilter(offset,f,'same','replicate')),fspecial('gaussian',9,1.5),'same','replicate');
+
+Min=min(foo(:));
+Max=max(foo(:));
+winSizeIm=wsize*(foo-Min)/(Max-Min)+wsize;
+
+
+

UVDoc_official/eval/eval_code/SIFTflow/computeColor.m

@@ -0,0 +1,115 @@
+function img = computeColor(u,v)
+
+%   computeColor color codes flow field U, V
+
+%   According to the c++ source code of Daniel Scharstein 
+%   Contact: schar@middlebury.edu
+
+%   Author: Deqing Sun, Department of Computer Science, Brown University
+%   Contact: dqsun@cs.brown.edu
+%   $Date: 2007-10-31 21:20:30 (Wed, 31 Oct 2006) $
+
+% Copyright 2007, Deqing Sun.
+%
+%                         All Rights Reserved
+%
+% Permission to use, copy, modify, and distribute this software and its
+% documentation for any purpose other than its incorporation into a
+% commercial product is hereby granted without fee, provided that the
+% above copyright notice appear in all copies and that both that
+% copyright notice and this permission notice appear in supporting
+% documentation, and that the name of the author and Brown University not be used in
+% advertising or publicity pertaining to distribution of the software
+% without specific, written prior permission.
+%
+% THE AUTHOR AND BROWN UNIVERSITY DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+% INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
+% PARTICULAR PURPOSE.  IN NO EVENT SHALL THE AUTHOR OR BROWN UNIVERSITY BE LIABLE FOR
+% ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 
+
+nanIdx = isnan(u) | isnan(v);
+u(nanIdx) = 0;
+v(nanIdx) = 0;
+
+colorwheel = makeColorwheel();
+ncols = size(colorwheel, 1);
+
+rad = sqrt(u.^2+v.^2);          
+
+a = atan2(-v, -u)/pi;
+
+fk = (a+1) /2 * (ncols-1) + 1;  % -1~1 maped to 1~ncols
+   
+k0 = floor(fk);                 % 1, 2, ..., ncols
+
+k1 = k0+1;
+k1(k1==ncols+1) = 1;
+
+f = fk - k0;
+
+for i = 1:size(colorwheel,2)
+    tmp = colorwheel(:,i);
+    col0 = tmp(k0)/255;
+    col1 = tmp(k1)/255;
+    col = (1-f).*col0 + f.*col1;   
+   
+    idx = rad <= 1;   
+    col(idx) = 1-rad(idx).*(1-col(idx));    % increase saturation with radius
+    
+    col(~idx) = col(~idx)*0.75;             % out of range
+    
+    img(:,:, i) = uint8(floor(255*col.*(1-nanIdx)));         
+end;    
+
+%%
+function colorwheel = makeColorwheel()
+
+%   color encoding scheme
+
+%   adapted from the color circle idea described at
+%   http://members.shaw.ca/quadibloc/other/colint.htm
+
+
+RY = 15;
+YG = 6;
+GC = 4;
+CB = 11;
+BM = 13;
+MR = 6;
+
+ncols = RY + YG + GC + CB + BM + MR;
+
+colorwheel = zeros(ncols, 3); % r g b
+
+col = 0;
+%RY
+colorwheel(1:RY, 1) = 255;
+colorwheel(1:RY, 2) = floor(255*(0:RY-1)/RY)';
+col = col+RY;
+
+%YG
+colorwheel(col+(1:YG), 1) = 255 - floor(255*(0:YG-1)/YG)';
+colorwheel(col+(1:YG), 2) = 255;
+col = col+YG;
+
+%GC
+colorwheel(col+(1:GC), 2) = 255;
+colorwheel(col+(1:GC), 3) = floor(255*(0:GC-1)/GC)';
+col = col+GC;
+
+%CB
+colorwheel(col+(1:CB), 2) = 255 - floor(255*(0:CB-1)/CB)';
+colorwheel(col+(1:CB), 3) = 255;
+col = col+CB;
+
+%BM
+colorwheel(col+(1:BM), 3) = 255;
+colorwheel(col+(1:BM), 1) = floor(255*(0:BM-1)/BM)';
+col = col+BM;
+
+%MR
+colorwheel(col+(1:MR), 3) = 255 - floor(255*(0:MR-1)/MR)';
+colorwheel(col+(1:MR), 1) = 255;

UVDoc_official/eval/eval_code/SIFTflow/demo.asv

@@ -0,0 +1,52 @@
+% im1=imread('Mars-1.jpg');
+% im2=imread('Mars-2.jpg');
+
+im1 = xcell{11, 2};
+im1 = rgb2gray(im1);
+im2 = ycell{11};
+im2 = rgb2gray(im2);
+% im1 = imresize(im1, size(im2));
+
+im1=imresize(imfilter(im1,fspecial('gaussian',7,1.),'same','replicate'),0.5,'bicubic');
+im2=imresize(imfilter(im2,fspecial('gaussian',7,1.),'same','replicate'),0.5,'bicubic');
+
+im1=im2double(im1);
+im2=im2double(im2);
+
+%figure;imshow(im1);figure;imshow(im2);
+
+cellsize=3;
+gridspacing=1;
+
+addpath(fullfile(pwd,'mexDenseSIFT'));
+addpath(fullfile(pwd,'mexDiscreteFlow'));
+
+sift1 = mexDenseSIFT(im1,cellsize,gridspacing);
+sift2 = mexDenseSIFT(im2,cellsize,gridspacing);
+
+SIFTflowpara.alpha=2*255;
+SIFTflowpara.d=40*255;
+SIFTflowpara.gamma=0.005*255;
+SIFTflowpara.nlevels=4;
+SIFTflowpara.wsize=2;
+SIFTflowpara.topwsize=10;
+SIFTflowpara.nTopIterations = 60;
+SIFTflowpara.nIterations= 30;
+
+
+tic;[vx,vy,energylist]=SIFTflowc2f(sift1,sift2,SIFTflowpara);toc
+
+warpI2=warpImage(im2,vx,vy);
+figure;imshow(im1);figure;imshow(warpI2);
+
+% display flow
+clear flow;
+flow(:,:,1)=vx;
+flow(:,:,2)=vy;
+figure;imshow(flowToColor(flow));
+
+return;
+
+% this is the code doing the brute force matching
+tic;[flow2,energylist2]=mexDiscreteFlow(Sift1,Sift2,[alpha,alpha*20,60,30]);toc
+figure;imshow(flowToColor(flow2));

UVDoc_official/eval/eval_code/SIFTflow/demo.m

@@ -0,0 +1,52 @@
+im1=imread('Mars-1.jpg');
+im2=imread('Mars-2.jpg');
+
+%im1 = ycell{36};
+im1 = rgb2gray(im1);
+%im2 = xcell{36, 2};
+im2 = rgb2gray(im2);
+% im2 = imresize(im2, size(im1));
+
+im1=imresize(imfilter(im1,fspecial('gaussian',3,1.),'same','replicate'),1,'bicubic');
+im2=imresize(imfilter(im2,fspecial('gaussian',3,1.),'same','replicate'),1,'bicubic');
+
+im1=im2double(im1);
+im2=im2double(im2);
+
+%figure;imshow(im1);figure;imshow(im2);
+
+cellsize=3;
+gridspacing=1;
+
+addpath(fullfile(pwd,'mexDenseSIFT'));
+addpath(fullfile(pwd,'mexDiscreteFlow'));
+
+sift1 = mexDenseSIFT(im1,cellsize,gridspacing);
+sift2 = mexDenseSIFT(im2,cellsize,gridspacing);
+
+SIFTflowpara.alpha=2*255;
+SIFTflowpara.d=40*255;
+SIFTflowpara.gamma=0.005*255;
+SIFTflowpara.nlevels=4;
+SIFTflowpara.wsize=2;
+SIFTflowpara.topwsize=10;
+SIFTflowpara.nTopIterations = 60;
+SIFTflowpara.nIterations= 30;
+
+
+tic;[vx,vy,energylist]=SIFTflowc2f(sift1,sift2,SIFTflowpara);toc
+
+warpI2=warpImage(im2,vx,vy);
+figure;imshow(im1);figure;imshow(warpI2);
+
+% display flow
+clear flow;
+flow(:,:,1)=vx;
+flow(:,:,2)=vy;
+figure;imshow(flowToColor(flow));
+
+return;
+
+% this is the code doing the brute force matching
+tic;[flow2,energylist2]=mexDiscreteFlow(Sift1,Sift2,[alpha,alpha*20,60,30]);toc
+figure;imshow(flowToColor(flow2));

UVDoc_official/eval/eval_code/SIFTflow/flowToColor.m

@@ -0,0 +1,88 @@
+function img = flowToColor(flow, varargin)
+
+%  flowToColor(flow, maxFlow) flowToColor color codes flow field, normalize
+%  based on specified value, 
+% 
+%  flowToColor(flow) flowToColor color codes flow field, normalize
+%  based on maximum flow present otherwise 
+
+%   According to the c++ source code of Daniel Scharstein 
+%   Contact: schar@middlebury.edu
+
+%   Author: Deqing Sun, Department of Computer Science, Brown University
+%   Contact: dqsun@cs.brown.edu
+%   $Date: 2007-10-31 18:33:30 (Wed, 31 Oct 2006) $
+
+% Copyright 2007, Deqing Sun.
+%
+%                         All Rights Reserved
+%
+% Permission to use, copy, modify, and distribute this software and its
+% documentation for any purpose other than its incorporation into a
+% commercial product is hereby granted without fee, provided that the
+% above copyright notice appear in all copies and that both that
+% copyright notice and this permission notice appear in supporting
+% documentation, and that the name of the author and Brown University not be used in
+% advertising or publicity pertaining to distribution of the software
+% without specific, written prior permission.
+%
+% THE AUTHOR AND BROWN UNIVERSITY DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+% INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
+% PARTICULAR PURPOSE.  IN NO EVENT SHALL THE AUTHOR OR BROWN UNIVERSITY BE LIABLE FOR
+% ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 
+
+UNKNOWN_FLOW_THRESH = 1e9;
+UNKNOWN_FLOW = 1e10;            % 
+
+[height widht nBands] = size(flow);
+
+if nBands ~= 2
+    error('flowToColor: image must have two bands');    
+end;    
+
+u = flow(:,:,1);
+v = flow(:,:,2);
+
+maxu = -999;
+maxv = -999;
+
+minu = 999;
+minv = 999;
+maxrad = -1;
+
+% fix unknown flow
+idxUnknown = (abs(u)> UNKNOWN_FLOW_THRESH) | (abs(v)> UNKNOWN_FLOW_THRESH) ;
+u(idxUnknown) = 0;
+v(idxUnknown) = 0;
+
+maxu = max(maxu, max(u(:)));
+minu = min(minu, min(u(:)));
+
+maxv = max(maxv, max(v(:)));
+minv = min(minv, min(v(:)));
+
+rad = sqrt(u.^2+v.^2);
+maxrad = max(maxrad, max(rad(:)));
+
+fprintf('max flow: %.4f flow range: u = %.3f .. %.3f; v = %.3f .. %.3f\n', maxrad, minu, maxu, minv, maxv);
+
+if isempty(varargin) ==0
+    maxFlow = varargin{1};
+    if maxFlow > 0
+        maxrad = maxFlow;
+    end;       
+end;
+
+u = u/(maxrad+eps);
+v = v/(maxrad+eps);
+
+% compute color
+
+img = computeColor(u, v);  
+    
+% unknown flow
+IDX = repmat(idxUnknown, [1 1 3]);
+img(IDX) = 0;

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/Image.h

@@ -0,0 +1,1788 @@
+#pragma once
+
+#include "project.h"
+#include "stdio.h"
+#include "memory.h"
+#include "ImageProcessing.h"
+#include <iostream>
+#include <fstream>
+#include <typeinfo>
+
+#ifndef _MATLAB
+	#include "ImageIO.h"
+#else
+	#include "mex.h"
+#endif
+
+using namespace std;
+
+// template class for image
+template <class T>
+class Image
+{
+public:
+	T* pData;
+	enum collapse_type{collapse_average,collapse_max,collapse_min};
+	enum color_type{RGB,BGR,DATA,GRAY};
+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<T>& other);
+	~Image(void);
+	virtual Image<T>& operator=(const Image<T>& other);
+
+	virtual inline void computeDimension(){nPixels=imWidth*imHeight;nElements=nPixels*nChannels;};
+
+	virtual void allocate(int width,int height,int nchannels=1);
+	
+	template <class T1>
+	void allocate(const Image<T1>& other);
+
+	virtual void clear();
+	virtual void reset();
+	virtual void copyData(const Image<T>& 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<nElements;i++)
+			Max=__max(Max,pData[i]);
+		return Max;
+	};
+	T immin() const{
+		T Min=pData[0];
+		for(int i=1;i<nElements;i++)
+			Min=__min(Min,pData[i]);
+		return Min;
+	}
+	template <class T1>
+	void copy(const Image<T1>& 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;};
+
+	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<imWidth && y>=0 && y<imHeight) return true; else return false;};
+
+	template <class T1>
+	bool matchDimension  (const Image<T1>& image) const;
+
+	bool matchDimension (int width,int height,int nchannels) const;
+
+	inline void setDerivative(bool isDerivativeImage=true){IsDerivativeImage=isDerivativeImage;};
+
+	// function to move this image to another one
+	template <class T1>
+	void moveto(Image<T1>& image,int x,int y,int width=0,int height=0);
+
+	// function of basic image operations
+	virtual bool imresize(double ratio);
+	template <class T1>
+	void imresize(Image<T1>& result,double ratio) const;
+	void imresize(int dstWidth,int dstHeight);
+	template <class T1>
+	void imresize(Image<T1>& result,int dstWidth,int dstHeight) const;
+
+	// get the string type
+	
+	// image IO's
+	virtual bool saveImage(const char* filename) const;
+	virtual bool loadImage(const char* filename);
+#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 <class T1>
+	Image<T1> dx (bool IsAdvancedFilter=false) const;
+
+	template <class T1>
+	void dx(Image<T1>& image,bool IsAdvancedFilter=false) const;
+
+	template<class T1>
+	Image<T1> dy(bool IsAdvancedFilter=false) const;
+
+	template <class T1>
+	void dy(Image<T1>& image,bool IsAdvancedFilter=false) const;
+
+	template <class T1>
+	void dxx(Image<T1>& image) const;
+
+	template <class T1>
+	void dyy(Image<T1>& image) const;
+
+	template <class T1>
+	void laplacian(Image<T1>& image) const;
+
+	template <class T1>
+	void gradientmag(Image<T1>& image) const;
+
+	template <class T1>
+	void GaussianSmoothing(Image<T1>& image,double sigma,int fsize) const;
+
+	template <class T1>
+	void smoothing(Image<T1>& image,double factor=4);
+
+	template <class T1>
+	Image<T1> smoothing(double factor=4);
+
+	void smoothing(double factor=4);
+
+	// funciton for filtering
+	template <class T1>
+	void imfilter(Image<T1>& image,double* filter,int fsize) const;
+
+	template <class T1>
+	Image<T1> imfilter(double* filter,int fsize);
+
+	template <class T1>
+	void imfilter_h(Image<T1>& image,double* filter,int fsize) const;
+
+	template <class T1>
+	void imfilter_v(Image<T1>& image,double* filter,int fsize) const;
+
+	template <class T1>
+	void imfilter_hv(Image<T1>& image,double* hfilter,int hfsize,double* vfilter,int vfsize) const;
+
+	// function to desaturating
+	template <class T1>
+	void desaturate(Image<T1>& image) const;
+
+	void desaturate();
+
+	template <class T1>
+	void collapse(Image<T1>& image,collapse_type type = collapse_average) const;
+
+	void collapse(collapse_type type = collapse_average);
+
+	// function to concatenate images
+	template <class T1,class T2>
+	void concatenate(Image<T1>& destImage,const Image<T2>& addImage) const;
+
+	template <class T1,class T2>
+	void concatenate(Image<T1>& destImage,const Image<T2>& addImage,double ratio) const;
+
+	template <class T1>
+	Image<T> concatenate(const Image<T1>& addImage) const;
+
+	// function to separate the channels of the image
+	template <class T1,class T2>
+	void separate(unsigned firstNChannels,Image<T1>& image1,Image<T2>& image2) const;
+
+	// function to sample patch
+	template <class T1>
+	void getPatch(Image<T1>& patch,double x,double y,int fsize) const;
+
+	// function to crop the image
+	template <class T1>
+	void crop(Image<T1>& patch,int Left,int Top,int Width,int Height) const;
+
+	// basic numerics of images
+	template <class T1,class T2>
+	void Multiply(const Image<T1>& image1,const Image<T2>& image2);
+
+	template <class T1,class T2,class T3>
+	void Multiply(const Image<T1>& image1,const Image<T2>& image2,const Image<T3>& image3);
+
+	template <class T1>
+	void Multiplywith(const Image<T1>& image1);
+
+	void Multiplywith(double value);
+
+	template <class T1,class T2>
+	void Add(const Image<T1>& image1,const Image<T2>& image2);
+
+	template <class T1,class T2>
+	void Add(const Image<T1>& image1,const Image<T2>& image2,double ratio);
+
+	void Add(const T value);
+
+	template <class T1>
+	void Add(const Image<T1>& image1,const double value);
+
+	template <class T1>
+	void Add(const Image<T1>& image1);
+
+	template <class T1,class T2>
+	void Subtract(const Image<T1>& image1,const Image<T2>& image2);
+
+	// function to normalize an image
+	void normalize(Image<T>& image);
+
+	// function to compute the statistics of the image
+	double norm2() const;
+
+	template <class T1>
+	double innerproduct(Image<T1>& image) const;
+
+	// function to bilateral smooth flow field
+	template <class T1>
+	void BilateralFiltering(Image<T1>& other,int fsize,double filter_signa,double range_sigma);
+
+	// function to bilateral smooth an image
+	//Image<T> BilateralFiltering(int fsize,double filter_sigma,double range_sigma);
+	void imBilateralFiltering(Image<T>& result,int fsize,double filter_sigma,double range_sigma);
+
+	// file IO
+#ifndef _MATLAB
+	//bool writeImage(QFile& file) const;
+	//bool readImage(QFile& file);
+	//bool writeImage(const QString& filename) const;
+	//bool readImage(const QString& filename);
+#endif
+
+#ifdef _MATLAB
+	bool LoadMatlabImage(const mxArray* image,bool IsImageScaleCovnersion=true);
+	template <class T1>
+	void LoadMatlabImageCore(const mxArray* image,bool IsImageScaleCovnersion=true);
+
+	template <class T1>
+	void ConvertFromMatlab(const T1* pMatlabPlane,int _width,int _height,int _nchannels);
+
+	void OutputToMatlab(mxArray*& matrix) const;
+
+	template <class T1>
+	void ConvertToMatlab(T1* pMatlabPlane) const;
+#endif
+};
+
+
+typedef Image<unsigned char> BiImage;
+typedef Image<unsigned char> UCImage;
+typedef Image<short int> IntImage;
+typedef Image<float> FImage;
+typedef Image<double> DImage;
+
+//------------------------------------------------------------------------------------------
+// constructor
+//------------------------------------------------------------------------------------------
+template <class T>
+Image<T>::Image()
+{
+	pData=NULL;
+	imWidth=imHeight=nChannels=nPixels=nElements=0;
+	IsDerivativeImage=false;
+}
+
+//------------------------------------------------------------------------------------------
+// constructor with specified dimensions
+//------------------------------------------------------------------------------------------
+template <class T>
+Image<T>::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 <class T>
+Image<T>::Image(const T& value,int _width,int _height,int _nchannels)
+{
+	pData=NULL;
+	allocate(_width,_height,_nchannels);
+	setValue(value);
+}
+
+#ifndef _MATLAB
+//template <class T>
+//Image<T>::Image(const QImage& image)
+//{
+//	pData=NULL;
+//	imread(image);
+//}
+#endif
+
+template <class T>
+void Image<T>::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 <class T>
+template <class T1>
+void Image<T>::allocate(const Image<T1> &other)
+{
+	allocate(other.width(),other.height(),other.nchannels());
+	isDerivativeImage = other.isDerivativeImage;
+	colorType = other.colorType;
+}
+
+//------------------------------------------------------------------------------------------
+// copy constructor
+//------------------------------------------------------------------------------------------
+template <class T>
+Image<T>::Image(const Image<T>& other)
+{
+	imWidth=imHeight=nChannels=nElements=0;
+	pData=NULL;
+	copyData(other);
+}
+
+//------------------------------------------------------------------------------------------
+// destructor
+//------------------------------------------------------------------------------------------
+template <class T>
+Image<T>::~Image()
+{
+	if(pData!=NULL)
+		delete []pData;
+}
+
+//------------------------------------------------------------------------------------------
+// clear the image
+//------------------------------------------------------------------------------------------
+template <class T>
+void Image<T>::clear()
+{
+	if(pData!=NULL)
+		delete []pData;
+	pData=NULL;
+	imWidth=imHeight=nChannels=nPixels=nElements=0;
+}
+
+//------------------------------------------------------------------------------------------
+// reset the image (reset the buffer to zero)
+//------------------------------------------------------------------------------------------
+template <class T>
+void Image<T>::reset()
+{
+	if(pData!=NULL)
+		memset(pData,0,sizeof(T)*nElements);
+}
+
+template <class T>
+void Image<T>::setValue(const T &value)
+{
+	for(int i=0;i<nElements;i++)
+		pData[i]=value;
+}
+
+template <class T>
+void Image<T>::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 <class T>
+void Image<T>::copyData(const Image<T>& 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 <class T>
+template <class T1>
+void Image<T>::copy(const Image<T1>& 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<nElements;i++)
+		pData[i]=srcData[i];
+}
+
+template <class T>
+void Image<T>::im2double()
+{
+	if(IsFloat())
+		for(int i=0;i<nElements;i++)
+			pData[i]/=255;
+}
+
+//------------------------------------------------------------------------------------------
+// override equal operator
+//------------------------------------------------------------------------------------------
+template <class T>
+Image<T>& Image<T>::operator=(const Image<T>& other)
+{
+	copyData(other);
+	return *this;
+}
+
+template <class T>
+bool Image<T>::IsFloat() const
+{
+	if(typeid(T)==typeid(float) || typeid(T)==typeid(double) || typeid(T)==typeid(long double))
+		return true;
+	else
+		return false;
+}
+
+template <class T>
+template <class T1>
+bool Image<T>::matchDimension(const Image<T1>& image) const
+{
+	if(imWidth==image.width() && imHeight==image.height() && nChannels==image.nchannels())
+		return true;
+	else
+		return false;
+}
+
+template <class T>
+bool Image<T>::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 <class T>
+template <class T1>
+void Image<T>::moveto(Image<T1>& 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<height;i++)
+	{
+		y=y0+i;
+		if(y>=image.height())
+			break;
+		for(int j=0;j<width;j++)
+		{
+			x=x0+j;
+			if(x>=image.width())
+				break;
+			for(int k=0;k<NChannels;k++)
+				image.data()[(y*image.width()+x)*image.nchannels()+k]=pData[(i*imWidth+j)*nChannels+k];
+		}
+	}
+}
+
+
+//------------------------------------------------------------------------------------------
+// resize the image
+//------------------------------------------------------------------------------------------
+template <class T>
+bool Image<T>::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 <class T>
+template <class T1>
+void Image<T>::imresize(Image<T1>& 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);
+	ImageProcessing::ResizeImage(pData,result.data(),imWidth,imHeight,nChannels,ratio);
+}
+
+template <class T>
+template <class T1>
+void Image<T>::imresize(Image<T1>& result,int DstWidth,int DstHeight) const
+{
+	if(result.width()!=DstWidth || result.height()!=DstHeight || result.nchannels()!=nChannels)
+		result.allocate(DstWidth,DstHeight,nChannels);
+	ImageProcessing::ResizeImage(pData,result.data(),imWidth,imHeight,nChannels,DstWidth,DstHeight);
+}
+
+
+template <class T>
+void Image<T>::imresize(int dstWidth,int dstHeight)
+{
+	DImage foo(dstWidth,dstHeight,nChannels);
+	ImageProcessing::ResizeImage(pData,foo.data(),imWidth,imHeight,nChannels,dstWidth,dstHeight);
+	copyData(foo);
+}
+
+//------------------------------------------------------------------------------------------
+// function of reading or writing images (uncompressed)
+//------------------------------------------------------------------------------------------
+template <class T>
+bool Image<T>::saveImage(const char *filename) const
+{
+	ofstream myfile(filename,ios::out | ios::binary);
+	if(myfile.is_open())
+	{
+		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);
+		myfile.close();
+		return true;
+	}
+	else
+		return false;
+}
+
+template <class T>
+bool Image<T>::loadImage(const char *filename)
+{
+	ifstream myfile(filename, ios::in | ios::binary);
+	if(myfile.is_open())
+	{
+		char type[16];
+		myfile.read(type,16);
+#ifdef _LINUX_MAC
+		if(strcasecmp(type,typeid(T).name())!=0)
+#else
+		if(_strcmpi(type,typeid(T).name())!=0)	
+#endif
+		{
+			cout<<"The type of the image is different from the type of the object!"<<endl;
+			return false;
+		}
+		int width,height,nchannels;
+		myfile.read((char *)&width,sizeof(int));
+		myfile.read((char *)&height,sizeof(int));
+		myfile.read((char *)&nchannels,sizeof(int));
+		if(!matchDimension(width,height,nchannels))
+			allocate(width,height,nchannels);
+		myfile.read((char *)&IsDerivativeImage,sizeof(bool));
+		myfile.read((char *)pData,sizeof(T)*nElements);
+		myfile.close();
+		return true;
+	}
+	else
+		return false;
+}
+
+
+//------------------------------------------------------------------------------------------
+// function to load the image
+//------------------------------------------------------------------------------------------
+#ifndef _MATLAB
+
+template <class T>
+bool Image<T>::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 <class T>
+//bool Image<T>::imread(const QString &filename)
+//{
+//	clear();
+//	if(ImageIO::loadImage(filename,pData,imWidth,imHeight,nChannels))
+//	{
+//		computeDimension();
+//		return true;
+//	}
+//	return false;
+//}
+//
+//template <class T>
+//void Image<T>::imread(const QImage& image)
+//{
+//	clear();
+//	ImageIO::loadImage(image,pData,imWidth,imHeight,nChannels);
+//	computeDimension();
+//}
+//
+ //------------------------------------------------------------------------------------------
+ // function to write the image 
+ //------------------------------------------------------------------------------------------
+template <class T>
+bool Image<T>::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 <class T>
+bool Image<T>::imwrite(const char* filename,ImageIO::ImageType type) const
+{
+	return ImageIO::saveImage(filename,pData,imWidth,imHeight,nChannels,type);
+}
+
+//template <class T>
+//bool Image<T>::imwrite(const QString &filename, ImageIO::ImageType imagetype, int quality) const
+//{
+//	return ImageIO::writeImage(filename,(const T*&)pData,imWidth,imHeight,nChannels,imagetype,quality);
+//}
+//
+//template <class T>
+//bool Image<T>::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 <class T>
+template <class T1>
+void Image<T>::dx(Image<T1>& 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<imHeight;i++)
+			for(j=0;j<imWidth-1;j++)
+			{
+				offset=i*imWidth+j;
+				for(k=0;k<nChannels;k++)
+					data[offset*nChannels+k]=(T1)pData[(offset+1)*nChannels+k]-pData[offset*nChannels+k];
+			}
+	else
+	{
+		double xFilter[5]={1,-8,0,8,-1};
+		for(i=0;i<5;i++)
+			xFilter[i]/=12;
+		ImageProcessing::hfiltering(pData,data,imWidth,imHeight,nChannels,xFilter,2);
+	}
+}
+
+template <class T>
+template <class T1>
+Image<T1> Image<T>::dx(bool IsAdvancedFilter) const
+{
+	Image<T1> result;
+	dx<T1>(result,IsAdvancedFilter);
+	return result;
+}
+
+//------------------------------------------------------------------------------------------
+// function to get y-derivative of the image
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::dy(Image<T1>& 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<imHeight-1;i++)
+			for(j=0;j<imWidth;j++)
+			{
+				offset=i*imWidth+j;
+				for(k=0;k<nChannels;k++)
+					data[offset*nChannels+k]=(T1)pData[(offset+imWidth)*nChannels+k]-pData[offset*nChannels+k];
+			}
+	else
+	{
+		double yFilter[5]={1,-8,0,8,-1};
+		for(i=0;i<5;i++)
+			yFilter[i]/=12;
+		ImageProcessing::vfiltering(pData,data,imWidth,imHeight,nChannels,yFilter,2);
+	}
+}
+
+template <class T>
+template <class T1>
+Image<T1> Image<T>::dy(bool IsAdvancedFilter) const
+{
+	Image<T1> result;
+	dy<T1>(result,IsAdvancedFilter);
+	return result;
+}
+
+//------------------------------------------------------------------------------------------
+// function to compute the second order derivative 
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::dxx(Image<T1> &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<imHeight;i++)
+			for(int j=0;j<imWidth;j++)
+			{
+				int offset=i*imWidth+j;
+				if(j==0)
+				{
+					pDstData[offset]=pData[offset]-pData[offset+1];
+					continue;
+				}
+				if(j==imWidth-1)
+				{
+					pDstData[offset]=pData[offset]-pData[offset-1];
+					continue;
+				}
+				pDstData[offset]=pData[offset]*2-pData[offset-1]-pData[offset+1];
+			}
+	else
+		for(int i=0;i<imHeight;i++)
+			for(int j=0;j<imWidth;j++)
+			{
+				int offset=(i*imWidth+j)*nChannels;
+				if(j==0)
+				{
+					for(int k=0;k<nChannels;k++)
+						pDstData[offset+k]=pData[offset+k]-pData[offset+nChannels+k];
+					continue;
+				}
+				if(j==imWidth-1)
+				{
+					for(int k=0;k<nChannels;k++)
+						pDstData[offset+k]=pData[offset+k]-pData[offset-nChannels+k];
+					continue;
+				}
+				for(int k=0;k<nChannels;k++)
+					pDstData[offset+k]=pData[offset+k]*2-pData[offset+nChannels+k]-pData[offset-nChannels+k];
+			}
+}
+
+template <class T>
+template <class T1>
+void Image<T>::dyy(Image<T1>& image) const
+{
+	if(!matchDimension(image))
+		image.allocate(imWidth,imHeight,nChannels);
+	T1* pDstData=image.data();
+	if(nChannels==1)
+		for(int i=0;i<imHeight;i++)
+			for(int j=0;j<imWidth;j++)
+			{
+				int offset=i*imWidth+j;
+				if(i==0)
+				{
+					pDstData[offset]=pData[offset]-pData[offset+imWidth];
+					continue;
+				}
+				if(i==imHeight-1)
+				{
+					pDstData[offset]=pData[offset]-pData[offset-imWidth];
+					continue;
+				}
+				pDstData[offset]=pData[offset]*2-pData[offset+imWidth]-pData[offset-imWidth];
+			}
+	else
+		for(int i=0;i<imHeight;i++)
+			for(int j=0;j<imWidth;j++)
+			{
+				int offset=(i*imWidth+j)*nChannels;
+				if(i==0)
+				{
+					for(int k=0;k<nChannels;k++)
+						pDstData[offset+k]=pData[offset+k]-pData[offset+imWidth*nChannels+k];
+					continue;
+				}
+				if(i==imHeight-1)
+				{
+					for(int k=0;k<nChannels;k++)
+						pDstData[offset+k]=pData[offset+k]-pData[offset-imWidth*nChannels+k];
+					continue;
+				}
+				for(int k=0;k<nChannels;k++)
+					pDstData[offset+k]=pData[offset+k]*2-pData[offset+imWidth*nChannels+k]-pData[offset-imWidth*nChannels+k];
+			}
+}
+
+//------------------------------------------------------------------------------------------
+// function for fast laplacian computation
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::laplacian(Image<T1> &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 <class T>
+template <class T1>
+void Image<T>::gradientmag(Image<T1> &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<nPixels;i++)
+	{
+		temp=0;
+		int offset=i*nChannels;
+		for(int k=0;k<nChannels;k++)
+		{
+			temp+=Ixdata[offset+k]*Ixdata[offset+k];
+			temp+=Iydata[offset+k]*Iydata[offset+k];
+		}
+		imagedata[i]=sqrt(temp);
+	}
+}
+
+//------------------------------------------------------------------------------------------
+// function to do Gaussian smoothing
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::GaussianSmoothing(Image<T1>& image,double sigma,int fsize) const 
+{
+	Image<T1> 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 smooth the image using a simple 3x3 filter
+// the filter is [1 factor 1]/(factor+2), applied horizontally and vertically
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::smoothing(Image<T1>& 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<T1>(image,filter2D,1);
+}
+
+template <class T>
+template <class T1>
+Image<T1> Image<T>::smoothing(double factor)
+{
+	Image<T1> result;
+	smoothing(result,factor);
+	return result;
+}
+
+template <class T>
+void Image<T>::smoothing(double factor)
+{
+	Image<T> result(imWidth,imHeight,nChannels);
+	smoothing(result,factor);
+	copyData(result);
+}
+
+//------------------------------------------------------------------------------------------
+//	 function of image filtering
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::imfilter(Image<T1>& image,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 <class T>
+template <class T1>
+Image<T1> Image<T>::imfilter(double *filter, int fsize)
+{
+	Image<T1> result;
+	imfilter(result,filter,fsize);
+	return result;
+}
+
+template <class T>
+template <class T1>
+void Image<T>::imfilter_h(Image<T1>& 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 <class T>
+template <class T1>
+void Image<T>::imfilter_v(Image<T1>& 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 <class T>
+template <class T1>
+void Image<T>::imfilter_hv(Image<T1> &image, double *hfilter, int hfsize, 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;
+}
+
+//------------------------------------------------------------------------------------------
+//	 function for desaturation
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::desaturate(Image<T1> &image) const
+{
+	if(nChannels!=3)
+	{
+		collapse(image);
+		return;
+	}
+	if(!(image.width()==imWidth && image.height()==imHeight && image.nChannels==1))
+		image.allocate(imWidth,imHeight,1);
+	T1* data=image.data();
+	int offset;
+	for(int i=0;i<nPixels;i++)
+	{
+		offset=i*3;
+		if(colorType == RGB)
+			data[i]=(double)pData[offset]*.299+pData[offset+1]*.587+pData[offset+2]*.114;
+		else
+			data[i]=(double)pData[offset]*.114+pData[offset+1]*.587+pData[offset+2]*.299;
+	}
+}
+
+template <class T>
+void Image<T>::desaturate()
+{
+	Image<T> temp;
+	desaturate(temp);
+	copyData(temp);
+}
+
+template <class T>
+template <class T1>
+void Image<T>::collapse(Image<T1> &image,collapse_type type) const
+{
+	if(!(image.width()==imWidth && image.height()==imHeight && image.nChannels==1))
+		image.allocate(imWidth,imHeight,1);
+	image.IsDerivativeImage = IsDerivativeImage;
+	if(nChannels == 1)
+	{
+		image.copy(*this);
+		return;
+	}
+	T1* data=image.data();
+	int offset;
+	double temp;
+	for(int i=0;i<nPixels;i++)
+	{
+		offset=i*nChannels;
+		switch(type){
+			case collapse_average:
+				temp=0;
+				for(int j=0;j<nChannels;j++)
+					temp+=pData[offset+j];
+				data[i]=temp/nChannels;
+				break;
+			case collapse_max:
+				data[i] = pData[offset];
+				for(int j=1;j<nChannels;j++)
+					data[i] = __max(data[i],pData[offset+j]);
+				break;
+			case collapse_min:
+				data[i] = pData[offset];
+				for(int j = 1;j<nChannels;j++)
+					data[i]=__min(data[i],pData[offset+j]);
+				break;
+		}
+	}
+}
+
+template <class T>
+void Image<T>::collapse(collapse_type type)
+{
+	if(nChannels == 1)
+		return;
+	Image<T> result;
+	collapse(result,type);
+	copyData(result);
+}
+
+//------------------------------------------------------------------------------------------
+//  function to concatenate two images
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1,class T2>
+void Image<T>::concatenate(Image<T1> &destImage, const Image<T2> &addImage) const
+{
+	if(addImage.width()!=imWidth || addImage.height()!=imHeight)
+	{
+		destImage.copy(*this);
+		return;
+	}
+	int extNChannels=nChannels+addImage.nchannels();
+	if(destImage.width()!=imWidth || destImage.height()!=imHeight || destImage.nchannels()!=extNChannels)
+		destImage.allocate(imWidth,imHeight,extNChannels);
+	int offset;
+	T1*& pDestData=destImage.data();
+	const T2*& pAddData=addImage.data();
+	for(int i=0;i<imHeight;i++)
+		for(int j=0;j<imWidth;j++)
+		{
+			offset=i*imWidth+j;
+			for(int k=0;k<nChannels;k++)
+				pDestData[offset*extNChannels+k]=pData[offset*nChannels+k];
+			for(int k=nChannels;k<extNChannels;k++)
+				pDestData[offset*extNChannels+k]=pAddData[offset*addImage.nchannels()+k-nChannels];
+		}
+}
+
+template <class T>
+template <class T1,class T2>
+void Image<T>::concatenate(Image<T1> &destImage, const Image<T2> &addImage,double ratio) const
+{
+	if(addImage.width()!=imWidth || addImage.height()!=imHeight)
+	{
+		destImage.copy(*this);
+		return;
+	}
+	int extNChannels=nChannels+addImage.nchannels();
+	if(destImage.width()!=imWidth || destImage.height()!=imHeight || destImage.nchannels()!=extNChannels)
+		destImage.allocate(imWidth,imHeight,extNChannels);
+	int offset;
+	T1*& pDestData=destImage.data();
+	const T2*& pAddData=addImage.data();
+	for(int i=0;i<imHeight;i++)
+		for(int j=0;j<imWidth;j++)
+		{
+			offset=i*imWidth+j;
+			for(int k=0;k<nChannels;k++)
+				pDestData[offset*extNChannels+k]=pData[offset*nChannels+k];
+			for(int k=nChannels;k<extNChannels;k++)
+				pDestData[offset*extNChannels+k]=pAddData[offset*addImage.nchannels()+k-nChannels]*ratio;
+		}
+}
+
+
+template <class T>
+template <class T1>
+Image<T> Image<T>::concatenate(const Image<T1> &addImage) const
+{
+	Image<T> destImage;
+	concatenate(destImage,addImage);
+	return destImage;
+}
+
+//------------------------------------------------------------------------------------------
+// function to separate the image into two
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1,class T2>
+void Image<T>::separate(unsigned int firstNChannels, Image<T1> &image1, Image<T2> &image2) const
+{
+	image1.IsDerivativeImage=IsDerivativeImage;
+	image2.IsDerivativeImage=IsDerivativeImage;
+
+	if(firstNChannels>=nChannels)
+	{
+		image1=*this;
+		image2.allocate(imWidth,imHeight,0);
+		return;
+	}
+	if(firstNChannels==0)
+	{
+		image1.allocate(imWidth,imHeight,0);
+		image2=*this;
+		return;
+	}
+	int secondNChannels=nChannels-firstNChannels;
+	if(image1.width()!=imWidth || image1.height()!=imHeight || image1.nchannels()!=firstNChannels)
+		image1.allocate(imWidth,imHeight,firstNChannels);
+	if(image2.width()!=imWidth || image2.height()!=imHeight || image2.nchannels()!=secondNChannels)
+		image2.allocate(imWidth,imHeight,secondNChannels);
+
+	for(int i=0;i<imHeight;i++)
+		for(int j=0;j<imWidth;j++)
+		{
+			int offset=i*imWidth+j;
+			for(int k=0;k<firstNChannels;k++)
+				image1.pData[offset*firstNChannels+k]=pData[offset*nChannels+k];
+			for(int k=firstNChannels;k<nChannels;k++)
+				image2.pData[offset*secondNChannels+k-firstNChannels]=pData[offset*nChannels+k];
+		}
+}
+
+//------------------------------------------------------------------------------------------
+// function to separate the image into two
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::getPatch(Image<T1>& patch,double x,double y,int wsize) const
+{
+	int wlength=wsize*2+1;
+	if(patch.width()!=wlength || patch.height()!=wlength || patch.nchannels()!=nChannels)
+		patch.allocate(wlength,wlength,nChannels);
+	else
+		patch.reset();
+	ImageProcessing::getPatch(pData,patch.data(),imWidth,imHeight,nChannels,x,y,wsize);
+}
+
+//------------------------------------------------------------------------------------------
+// function to crop an image
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::crop(Image<T1>& patch,int Left,int Top,int Width,int Height) const
+{
+	if(patch.width()!=Width || patch.height()!=Height || patch.nchannels()!=nChannels)
+		patch.allocate(Width,Height,nChannels);
+	// make sure that the cropping is valid
+	if(Left<0 || Top<0 || Left>=imWidth || Top>=imHeight)
+	{
+		cout<<"The cropping coordinate is outside the image boundary!"<<endl;
+		return;
+	}
+	if(Width<0 || Height<0 || Width+Left>imWidth || Height+Top>imHeight)
+	{
+		cout<<"The patch to crop is invalid!"<<endl;
+		return;
+	}
+	ImageProcessing::cropImage(pData,imWidth,imHeight,nChannels,patch.data(),Left,Top,Width,Height);
+}
+
+//------------------------------------------------------------------------------------------
+// function to multiply image1, image2 and image3 to the current image
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1,class T2,class T3>
+void Image<T>::Multiply(const Image<T1>& image1,const Image<T2>& image2,const Image<T3>& image3)
+{
+	if(image1.matchDimension(image2)==false || image2.matchDimension(image3)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Multiply()!"<<endl;
+		return;
+	}
+	if(matchDimension(image1)==false)
+		allocate(image1);
+
+	const T1*& pData1=image1.data();
+	const T2*& pData2=image2.data();
+	const T3*& pData3=image3.data();
+
+	for(int i=0;i<nElements;i++)
+		pData[i]=pData1[i]*pData2[i]*pData3[i];
+}
+
+template <class T>
+template <class T1,class T2>
+void Image<T>::Multiply(const Image<T1>& image1,const Image<T2>& image2)
+{
+	if(image1.matchDimension(image2)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Multiply()!"<<endl;
+		return;
+	}
+	if(matchDimension(image1)==false)
+		allocate(image1);
+
+	const T1*& pData1=image1.data();
+	const T2*& pData2=image2.data();
+
+	for(int i=0;i<nElements;i++)
+		pData[i]=pData1[i]*pData2[i];
+}
+
+template <class T>
+template <class T1>
+void Image<T>::Multiplywith(const Image<T1> &image1)
+{
+	if(matchDimension(image1)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Multiplywith()!"<<endl;
+		return;
+	}
+	const T1*& pData1=image1.data();
+	for(int i=0;i<nElements;i++)
+		pData[i]*=pData1[i];
+}
+
+template <class T>
+void Image<T>::Multiplywith(double value)
+{
+	for(int i=0;i<nElements;i++)
+		pData[i]*=value;
+}
+
+//------------------------------------------------------------------------------------------
+// function to add image2 to image1 to the current image
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1,class T2>
+void Image<T>::Add(const Image<T1>& image1,const Image<T2>& image2)
+{
+	if(image1.matchDimension(image2)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Add()!"<<endl;
+		return;
+	}
+	if(matchDimension(image1)==false)
+		allocate(image1);
+
+	const T1*& pData1=image1.data();
+	const T2*& pData2=image2.data();
+	for(int i=0;i<nElements;i++)
+		pData[i]=pData1[i]+pData2[i];	
+}
+
+template <class T>
+template <class T1,class T2>
+void Image<T>::Add(const Image<T1>& image1,const Image<T2>& image2,double ratio)
+{
+	if(image1.matchDimension(image2)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Add()!"<<endl;
+		return;
+	}
+	if(matchDimension(image1)==false)
+		allocate(image1);
+
+	const T1*& pData1=image1.data();
+	const T2*& pData2=image2.data();
+	for(int i=0;i<nElements;i++)
+		pData[i]=pData1[i]+pData2[i]*ratio;	
+}
+
+template <class T>
+template <class T1>
+void Image<T>::Add(const Image<T1>& image1,const double ratio)
+{
+	if(matchDimension(image1)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Add()!"<<endl;
+		return;
+	}
+	const T1*& pData1=image1.data();
+	for(int i=0;i<nElements;i++)
+		pData[i]+=pData1[i]*ratio;	
+}
+
+template <class T>
+template <class T1>
+void Image<T>::Add(const Image<T1>& image1)
+{
+	if(matchDimension(image1)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Add()!"<<endl;
+		return;
+	}
+	const T1*& pData1=image1.data();
+	for(int i=0;i<nElements;i++)
+		pData[i]+=pData1[i];	
+}
+
+
+template <class T>
+void Image<T>::Add(const T value)
+{
+	for(int i=0;i<nElements;i++)
+		pData[i]+=value;
+}
+
+//------------------------------------------------------------------------------------------
+// function to subtract image2 from image1
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1,class T2>
+void Image<T>::Subtract(const Image<T1> &image1, const Image<T2> &image2)
+{
+	if(image1.matchDimension(image2)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Add()!"<<endl;
+		return;
+	}
+	if(matchDimension(image1)==false)
+		allocate(image1);
+
+	const T1*& pData1=image1.data();
+	const T2*& pData2=image2.data();
+	for(int i=0;i<nElements;i++)
+		pData[i]=pData1[i]-pData2[i];
+}
+
+//------------------------------------------------------------------------------------------
+// normalize an image
+//------------------------------------------------------------------------------------------
+template <class T>
+void Image<T>::normalize(Image<T>& image)
+{
+	if(image.width()!=imWidth || image.height()!=imHeight || image.nchannels()!=nChannels)
+		image.allocate(imWidth,imHeight,nChannels);
+	T Max =immax(),Min =immin();
+	if(Max==Min)
+		return;
+	double ratio=1/(Max-Min);
+	if(IsFloat()==false)
+		ratio*=255;
+	T* data=image.data();
+	for(int i=0;i<nElements;i++)
+		data[i]=(double)(pData[i]-Min)*ratio;
+}
+
+template <class T>
+double Image<T>::norm2() const
+{
+	double result=0;
+	for(int i=0;i<nElements;i++)
+		result+=pData[i]*pData[i];
+	return result;
+}
+
+template <class T>
+template <class T1>
+double Image<T>::innerproduct(Image<T1> &image) const
+{
+	double result=0;
+	const T1* pData1=image.data();
+	for(int i=0;i<nElements;i++)
+		result+=pData[i]*pData1[i];
+	return result;
+}
+
+#ifndef _MATLAB
+//template <class T>
+//bool Image<T>::writeImage(QFile &file) const
+//{
+//	file.write((char *)&imWidth,sizeof(int));
+//	file.write((char *)&imHeight,sizeof(int));
+//	file.write((char *)&nChannels,sizeof(int));
+//	file.write((char *)&IsDerivativeImage,sizeof(bool));
+//	if(file.write((char *)pData,sizeof(T)*nElements)!=sizeof(T)*nElements)
+//		return false;
+//	return true;
+//}
+//
+//template <class T>
+//bool Image<T>::readImage(QFile& file)
+//{
+//	clear();
+//	file.read((char *)&imWidth,sizeof(int));
+//	file.read((char *)&imHeight,sizeof(int));
+//	file.read((char *)&nChannels,sizeof(int));
+//	file.read((char *)&IsDerivativeImage,sizeof(bool));
+//	if(imWidth<0 ||imWidth>100000 || imHeight<0 || imHeight>100000 || nChannels<0 || nChannels>10000)
+//		return false;
+//	allocate(imWidth,imHeight,nChannels);
+//	if(file.read((char *)pData,sizeof(T)*nElements)!=sizeof(T)*nElements)
+//		return false;
+//	return true;
+//}
+//
+//template <class T>
+//bool Image<T>::writeImage(const QString &filename) const
+//{
+//	QFile file(filename);
+//	if(file.open(QIODevice::WriteOnly)==false)
+//		return false;
+//	if(!writeImage(file))
+//		return false;
+//	return true;
+//}
+//
+//template <class T>
+//bool Image<T>::readImage(const QString &filename)
+//{
+//	QFile file(filename);
+//	if(file.open(QIODevice::ReadOnly)==false)
+//		return false;
+//	if(!readImage(file))
+//		return false;
+//	return true;
+//}
+#endif
+
+
+template <class T>
+template <class T1>
+void Image<T>::BilateralFiltering(Image<T1>& other,int fsize,double filter_sigma,double range_sigma)
+{
+	double *pBuffer;
+	Image<T1> result(other);
+	pBuffer=new double[other.nchannels()];
+
+	// set spatial weight to save time
+	double *pSpatialWeight;
+	int flength = fsize*2+1;
+	pSpatialWeight = new double[flength*flength];
+	for(int i=-fsize;i<=fsize;i++)
+		for(int j=-fsize;j<=fsize;j++)
+			pSpatialWeight[(i+fsize)*flength+j+fsize]=exp(-(double)(i*i+j*j)/(2*filter_sigma*filter_sigma));
+
+	for(int i=0;i<imHeight;i++)
+		for(int j=0;j<imWidth;j++)
+		{
+			double totalWeight=0;
+			for(int k=0;k<other.nchannels();k++)
+				pBuffer[k]=0;
+			for(int ii=-fsize;ii<=fsize;ii++)
+				for(int jj=-fsize;jj<=fsize;jj++)
+				{
+					int x=j+jj;
+					int y=i+ii;
+					if(x<0 || x>=imWidth || y<0 || y>=imHeight)
+						continue;
+
+					// compute weight
+					int offset=(y*imWidth+x)*nChannels;
+					double temp=0;
+					for(int k=0;k<nChannels;k++)
+					{
+						double diff=pData[offset+k]-pData[(i*imWidth+j)*nChannels+k];
+						temp+=diff*diff;
+					}
+					double weight=exp(-temp/(2*range_sigma*range_sigma));
+					weight *= pSpatialWeight[(ii+fsize)*flength+jj+fsize];
+					//weight*=exp(-(double)(ii*ii+jj*jj)/(2*filter_sigma*filter_sigma));
+					totalWeight+=weight;
+					for(int k=0;k<other.nchannels();k++)
+						pBuffer[k]+=other.data()[(y*imWidth+x)*other.nchannels()+k]*weight;
+				}
+			for(int k=0;k<other.nchannels();k++)
+				result.data()[(i*imWidth+j)*other.nchannels()]=pBuffer[k]/totalWeight;
+		}
+	other.copyData(result);
+	delete pBuffer;
+	delete pSpatialWeight;
+}
+
+
+template <class T>
+//Image<T>  Image<T>::BilateralFiltering(int fsize,double filter_sigma,double range_sigma)
+void  Image<T>::imBilateralFiltering(Image<T>& result,int fsize,double filter_sigma,double range_sigma)
+{
+	//Image<T> result(*this);
+	result.allocate(*this);
+
+	double *pBuffer;
+	pBuffer=new double[nChannels];
+
+	// set spatial weight to save time
+	double *pSpatialWeight;
+	int flength = fsize*2+1;
+	pSpatialWeight = new double[flength*flength];
+	for(int i=-fsize;i<=fsize;i++)
+		for(int j=-fsize;j<=fsize;j++)
+			pSpatialWeight[(i+fsize)*flength+j+fsize]=exp(-(double)(i*i+j*j)/(2*filter_sigma*filter_sigma));
+
+	for(int i=0;i<imHeight;i++)
+		for(int j=0;j<imWidth;j++)
+		{
+			double totalWeight=0;
+			for(int k=0;k<nChannels;k++)
+				pBuffer[k]=0;
+			int offset0 = (i*imWidth+j)*nChannels;
+			for(int ii=-fsize;ii<=fsize;ii++)
+				for(int jj=-fsize;jj<=fsize;jj++)
+				{
+					int x=j+jj;
+					int y=i+ii;
+					if(x<0 || x>=imWidth || y<0 || y>=imHeight)
+						continue;
+
+					// compute weight
+					int offset=(y*imWidth+x)*nChannels;
+					double temp=0;
+					for(int k=0;k<nChannels;k++)
+					{
+						double diff=pData[offset+k]-pData[offset0+k];
+						temp+=diff*diff;
+					}
+					double weight=exp(-temp/(2*range_sigma*range_sigma));
+					weight *= pSpatialWeight[(ii+fsize)*flength+jj+fsize];
+
+					//weight*=exp(-(double)(ii*ii+jj*jj)/(2*filter_sigma*filter_sigma));
+					totalWeight+=weight;
+					for(int k=0;k<nChannels;k++)
+						pBuffer[k]+=pData[offset+k]*weight;
+				}
+			for(int k=0;k<nChannels;k++)
+				result.data()[offset0+k]=pBuffer[k]/totalWeight;
+
+		}
+	delete pBuffer;
+	delete pSpatialWeight;
+	//return result;
+}
+
+#ifdef _MATLAB
+
+template <class T>
+template <class T1>
+void Image<T>::LoadMatlabImageCore(const mxArray *image,bool IsImageScaleCovnersion)
+{
+	int nDim = mxGetNumberOfDimensions(image);
+	const mwSize* imDim = mxGetDimensions(image);
+	if(nDim==2)
+		allocate(imDim[1],imDim[0]);
+	else if(nDim==3)
+		allocate(imDim[1],imDim[0],imDim[2]);
+	else
+		mexErrMsgTxt("The image doesn't have the appropriate dimension!");
+	T1* pMatlabPlane=(T1*)mxGetData(image);
+	bool IsMatlabFloat;
+	if(typeid(T1)==typeid(float) || typeid(T1)==typeid(double) || typeid(T1)==typeid(long double))
+		IsMatlabFloat=true;
+	else
+		IsMatlabFloat=false;
+	bool isfloat=IsFloat();
+	if(isfloat==IsMatlabFloat || IsImageScaleCovnersion==false)
+	{
+		ConvertFromMatlab<T1>(pMatlabPlane,imWidth,imHeight,nChannels);
+		return;
+	}
+	int offset=0;
+	if(isfloat==true)
+		for(int i=0;i<imHeight;i++)
+			for(int j=0;j<imWidth;j++)
+				for(int k=0;k<nChannels;k++)
+					pData[offset++]=(double)pMatlabPlane[k*nPixels+j*imHeight+i]/255;
+	else
+		for(int i=0;i<imHeight;i++)
+			for(int j=0;j<imWidth;j++)
+				for(int k=0;k<nChannels;k++)
+					pData[offset++]=(double)pMatlabPlane[k*nPixels+j*imHeight+i]*255;
+}
+
+template <class T>
+bool Image<T>::LoadMatlabImage(const mxArray* matrix,bool IsImageScaleCovnersion)
+{
+	colorType = RGB; // the color is RGB when we use matlab to load the image
+	if(mxIsClass(matrix,"uint8"))
+	{
+		LoadMatlabImageCore<unsigned char>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	if(mxIsClass(matrix,"int8"))
+	{
+		LoadMatlabImageCore<char>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	if(mxIsClass(matrix,"int32"))
+	{
+		LoadMatlabImageCore<int>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	if(mxIsClass(matrix,"uint32"))
+	{
+		LoadMatlabImageCore<unsigned int>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	if(mxIsClass(matrix,"int16"))
+	{
+		LoadMatlabImageCore<short int>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	if(mxIsClass(matrix,"uint16"))
+	{
+		LoadMatlabImageCore<unsigned short int>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	if(mxIsClass(matrix,"single"))
+	{
+		LoadMatlabImageCore<float>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	if(mxIsClass(matrix,"double"))
+	{
+		LoadMatlabImageCore<double>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	mexErrMsgTxt("Unknown type of the image!");
+	return false;
+}
+
+
+template <class T>
+template <class T1>
+void Image<T>::ConvertFromMatlab(const T1 *pMatlabPlane, int _width, int _height, int _nchannels)
+{
+	if(imWidth!=_width || imHeight!=_height || nChannels!=_nchannels)
+		allocate(_width,_height,_nchannels);
+	int offset=0;
+	for(int i=0;i<imHeight;i++)
+		for(int j=0;j<imWidth;j++)
+			for(int k=0;k<nChannels;k++)
+				pData[offset++]=pMatlabPlane[k*nPixels+j*imHeight+i];
+}
+
+// convert image data to matlab matrix
+template <class T>
+template <class T1>
+void Image<T>::ConvertToMatlab(T1 *pMatlabPlane) const
+{
+	int offset=0;
+	for(int i=0;i<imHeight;i++)
+		for(int j=0;j<imWidth;j++)
+			for(int k=0;k<nChannels;k++)
+				pMatlabPlane[k*nPixels+j*imHeight+i]=pData[offset++];
+}
+
+template <class T>
+void Image<T>::OutputToMatlab(mxArray *&matrix) const
+{
+	mwSize dims[3];
+	dims[0]=imHeight;
+	dims[1]=imWidth;
+	dims[2]=nChannels;
+	int nDims;
+	nDims = (nChannels ==1)? 2:3;
+	if(typeid(T) == typeid(unsigned char))
+		matrix=mxCreateNumericArray(nDims, dims,mxUINT8_CLASS, mxREAL);
+	if(typeid(T) == typeid(char))
+		matrix=mxCreateNumericArray(nDims, dims,mxINT8_CLASS, mxREAL);
+	if(typeid(T) == typeid(short int))
+		matrix=mxCreateNumericArray(nDims, dims,mxINT16_CLASS, mxREAL);
+	if(typeid(T) == typeid(unsigned short int))
+		matrix=mxCreateNumericArray(nDims, dims,mxUINT16_CLASS, mxREAL);
+	if(typeid(T) == typeid(int))
+		matrix=mxCreateNumericArray(nDims, dims,mxINT32_CLASS, mxREAL);
+	if(typeid(T) == typeid(unsigned int))
+		matrix=mxCreateNumericArray(nDims, dims,mxUINT32_CLASS, mxREAL);
+	if(typeid(T) == typeid(float))
+		matrix=mxCreateNumericArray(nDims, dims,mxSINGLE_CLASS, mxREAL);
+	if(typeid(T) == typeid(double))
+		matrix=mxCreateNumericArray(nDims, dims,mxDOUBLE_CLASS, mxREAL);
+
+	ConvertToMatlab<T>((T*)mxGetData(matrix));
+}
+
+#endif
+
+

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/ImageFeature.h

@@ -0,0 +1,283 @@
+#pragma once
+#include "Image.h"
+#include "math.h"
+#include "memory.h"
+#include <vector>
+
+#ifndef M_PI
+#define M_PI 3.1415926535897932384626433
+#endif
+
+
+class ImageFeature
+{
+public:
+	ImageFeature(void);
+	~ImageFeature(void);
+	
+	template <class T1,class T2>
+	static void imSIFT(const Image<T1> imsrc, Image<T2>& imsift, int cellSize = 2, int stepSize = 1,bool IsBoundaryIncluded = false,int nBins = 8);
+
+	template <class T1,class T2>
+	static void imSIFT(const Image<T1> imsrc, Image<T2>& imsift, const vector<int> cellSizeVect, int stepSize = 1,bool IsBoundaryIncluded = false, int nBins = 8);
+};
+
+template <class T1,class T2>
+void ImageFeature::imSIFT(const Image<T1> imsrc, Image<T2> &imsift,int cellSize,int stepSize,bool IsBoundaryIncluded,int nBins)
+{
+	if(cellSize<=0)
+	{
+		cout<<"The cell size must be positive!"<<endl;
+		return;
+	}
+
+	// this parameter controls decay of the gradient energy falls into a bin
+	// run SIFT_weightFunc.m to see why alpha = 9 is the best value
+	int alpha = 9; 
+
+	int width=imsrc.width(),height=imsrc.height(),nchannels =imsrc.nchannels();
+	int nPixels = width*height;
+	DImage imdx,imdy;
+	// compute the derivatives;
+	imsrc.dx(imdx,true);
+	imsrc.dy(imdy,true);
+
+	// get the maximum gradient over the channels and estimate the normalized gradient
+	DImage magsrc(width,height,nchannels),mag(width,height),gradient(width,height,2);
+	double Max;
+	for(int i=0;i<nPixels;i++)
+	{
+		int offset = i*nchannels;
+		for(int j = 0;j<nchannels;j++)
+			magsrc.pData[offset+j] = sqrt(imdx.pData[offset+j]*imdx.pData[offset+j]+imdy.pData[offset+j]*imdy.pData[offset+j]);
+		Max = magsrc.pData[offset];
+		if(Max!=0)
+		{
+			gradient.pData[i*2] = imdx.pData[offset]/Max;
+			gradient.pData[i*2+1] = imdy.pData[offset]/Max;
+		}		
+		for(int j = 1;j<nchannels;j++)
+		{
+			if(magsrc.pData[offset+j]>Max)
+			{
+				Max = magsrc.pData[offset+j];
+				gradient.pData[i*2] = imdx.pData[offset+j]/Max;
+				gradient.pData[i*2+1] = imdy.pData[offset+j]/Max;
+			}
+		}
+		mag.pData[i] = Max;
+	}
+
+	// get the pixel-wise energy for each orientation band
+	DImage imband(width,height,nBins);
+	double theta = M_PI*2/nBins;
+	double _cos,_sin,temp;
+	for(int k = 0;k<nBins;k++)
+	{
+		_sin    = sin(theta*k);
+		_cos   = cos(theta*k);
+		for(int i = 0;i<nPixels; i++)
+		{
+			temp = __max(gradient.pData[i*2]*_cos + gradient.pData[i*2+1]*_sin,0);
+			if(alpha>1)
+				temp = pow(temp,alpha);
+			imband.pData[i*nBins+k] = temp*mag.pData[i]; 
+		}
+	}
+
+	// filter out the SIFT feature
+	DImage filter(cellSize*2+1,1);
+	filter[0] = filter[cellSize+1] = 0.25;
+	for(int i = 1;i<cellSize+1;i++)
+		filter[i+1] = 1;
+	for(int i = cellSize+2;i<cellSize*2+1;i++)
+		filter[i] = 0;
+
+    DImage imband_cell;
+	imband.imfilter_hv(imband_cell,filter.data(),cellSize,filter.data(),cellSize);
+
+	// allocate buffer for the sift image
+	int siftdim = nBins*16;
+	int sift_width,sift_height,x_shift=0,y_shift=0;
+
+	sift_width = width/stepSize;
+	sift_height = height/stepSize;
+
+	if(IsBoundaryIncluded == false)
+	{
+		sift_width = (width-4*cellSize)/stepSize;
+		sift_height= (height-4*cellSize)/stepSize;
+		x_shift = 2*cellSize;
+		y_shift = 2*cellSize;
+	}
+
+	if(!imsift.matchDimension(sift_width,sift_height,siftdim))
+		imsift.allocate(sift_width,sift_height,siftdim);
+
+	// now sample to get SIFT image
+	DImage sift_cell(siftdim,1);
+	for(int i=0;i<sift_height;i++)
+		for(int j =0;j<sift_width;j++)
+		{
+			int count = 0;
+			for(int ii = -1;ii<=2;ii++)
+				for(int jj=-1;jj<=2;jj++)
+				{
+					int y = __min(__max(y_shift+i*stepSize+ii*cellSize,0),height-1);
+					int x = __min(__max(x_shift+j*stepSize+jj*cellSize,0),width-1);
+					
+					// the following code is the same as the above two for debugging purposes
+					//int y = y_shift+i*stepSize+ii*cellSize;
+					//int x = x_shift+j*stepSize+jj*cellSize;
+					//if (x<0 || x>=width)
+					//	x = __min(__max(x,0),width-1);
+					//if (y<0 || y>=height)
+					//	y= __min(__max(y,0),height-1);
+
+					memcpy(sift_cell.pData+count*nBins,imband_cell.pData+(y*width+x)*nBins,sizeof(double)*nBins);
+					count++;
+				}
+			// normalize the SIFT descriptor
+			double mag = sqrt(sift_cell.norm2());
+			int offset = (i*sift_width+j)*siftdim;
+			//memcpy(imsift.pData+offset,sift_cell.pData,sizeof(double)*siftdim);
+			for(int k = 0;k<siftdim;k++)
+				imsift.pData[offset+k] = (unsigned char)__min(sift_cell.pData[k]/(mag+0.01)*255,255);//(unsigned char) __min(sift_cell.pData[k]/mag*512,255);
+		}//*/
+}
+
+
+//--------------------------------------------------------------------------------------------------
+// multi-scale SIFT features
+//--------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageFeature::imSIFT(const Image<T1> imsrc, Image<T2> &imsift,const vector<int> cellSizeVect,int stepSize,bool IsBoundaryIncluded,int nBins)
+{
+	// this parameter controls decay of the gradient energy falls into a bin
+	// run SIFT_weightFunc.m to see why alpha = 9 is the best value
+	int alpha = 9; 
+
+	int width=imsrc.width(),height=imsrc.height(),nchannels =imsrc.nchannels();
+	int nPixels = width*height;
+	DImage imdx,imdy;
+	// compute the derivatives;
+	imsrc.dx(imdx,true);
+	imsrc.dy(imdy,true);
+
+	// get the maximum gradient over the channels and estimate the normalized gradient
+	DImage magsrc(width,height,nchannels),mag(width,height),gradient(width,height,2);
+	double Max;
+	for(int i=0;i<nPixels;i++)
+	{
+		int offset = i*nchannels;
+		for(int j = 0;j<nchannels;j++)
+			magsrc.pData[offset+j] = sqrt(imdx.pData[offset+j]*imdx.pData[offset+j]+imdy.pData[offset+j]*imdy.pData[offset+j]);
+		Max = magsrc.pData[offset];
+		if(Max!=0)
+		{
+			gradient.pData[i*2] = imdx.pData[offset]/Max;
+			gradient.pData[i*2+1] = imdy.pData[offset]/Max;
+		}		
+		for(int j = 1;j<nchannels;j++)
+		{
+			if(magsrc.pData[offset+j]>Max)
+			{
+				Max = magsrc.pData[offset+j];
+				gradient.pData[i*2] = imdx.pData[offset+j]/Max;
+				gradient.pData[i*2+1] = imdy.pData[offset+j]/Max;
+			}
+		}
+		mag.pData[i] = Max;
+	}
+
+	// get the pixel-wise energy for each orientation band
+	DImage imband(width,height,nBins);
+	double theta = M_PI*2/nBins;
+	double _cos,_sin,temp;
+	for(int k = 0;k<nBins;k++)
+	{
+		_sin    = sin(theta*k);
+		_cos   = cos(theta*k);
+		for(int i = 0;i<nPixels; i++)
+		{
+			temp = __max(gradient.pData[i*2]*_cos + gradient.pData[i*2+1]*_sin,0);
+			if(alpha>1)
+				temp = pow(temp,alpha);
+			imband.pData[i*nBins+k] = temp*mag.pData[i]; 
+		}
+	}
+	// get the maximum cell size
+	int maxCellSize = cellSizeVect[0];
+	int nScales = cellSizeVect.size();
+	for(int h=1;h<nScales;h++)
+		maxCellSize = __max(maxCellSize,cellSizeVect[h]);
+
+	// allocate buffer for the sift image
+	int siftdim = nBins*16;
+	int sift_width,sift_height,x_shift=0,y_shift=0;
+
+	sift_width = width/stepSize;
+	sift_height = height/stepSize;
+
+	if(IsBoundaryIncluded == false)
+	{
+		sift_width = (width-4*maxCellSize)/stepSize;
+		sift_height= (height-4*maxCellSize)/stepSize;
+		x_shift = 2*maxCellSize;
+		y_shift = 2*maxCellSize;
+	}
+
+	if(!imsift.matchDimension(sift_width,sift_height,siftdim*nScales))
+		imsift.allocate(sift_width,sift_height,siftdim*nScales);
+
+	for(int h=0;h<nScales;h++)
+	{
+		int cellSize = cellSizeVect[h];
+		if(cellSize<=0)
+		{
+			cout<<"The cell size must be positive!"<<endl;
+			return;
+		}
+		// filter out the SIFT feature
+		DImage filter(cellSize*2+1,1);
+		filter[0] = filter[cellSize+1] = 0.25;
+		for(int i = 1;i<cellSize+1;i++)
+			filter[i+1] = 1;
+		for(int i = cellSize+2;i<cellSize*2+1;i++)
+			filter[i] = 0;
+
+		DImage imband_cell;
+		imband.imfilter_hv(imband_cell,filter.data(),cellSize,filter.data(),cellSize);
+
+		// now sample to get SIFT image
+		DImage sift_cell(siftdim,1);
+		for(int i=0;i<sift_height;i++)
+			for(int j =0;j<sift_width;j++)
+			{
+				int count = 0;
+				for(int ii = -1;ii<=2;ii++)
+					for(int jj=-1;jj<=2;jj++)
+					{
+						int y = __min(__max(y_shift+i*stepSize+ii*cellSize,0),height-1);
+						int x = __min(__max(x_shift+j*stepSize+jj*cellSize,0),width-1);
+						
+						// the following code is the same as the above two for debugging purposes
+						//int y = y_shift+i*stepSize+ii*cellSize;
+						//int x = x_shift+j*stepSize+jj*cellSize;
+						//if (x<0 || x>=width)
+						//	x = __min(__max(x,0),width-1);
+						//if (y<0 || y>=height)
+						//	y= __min(__max(y,0),height-1);
+
+						memcpy(sift_cell.pData+count*nBins,imband_cell.pData+(y*width+x)*nBins,sizeof(double)*nBins);
+						count++;
+					}
+				// normalize the SIFT descriptor
+				double mag = sqrt(sift_cell.norm2());
+				int offset = (i*sift_width+j)*siftdim*nScales+h*siftdim;
+				//memcpy(imsift.pData+offset,sift_cell.pData,sizeof(double)*siftdim);
+				for(int k = 0;k<siftdim;k++)
+					imsift.pData[offset+k] = (unsigned char)__min(sift_cell.pData[k]/(mag+0.01)*255,255);//(unsigned char) __min(sift_cell.pData[k]/mag*512,255);
+			}//*/
+	}
+}

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/ImageIO.h

@@ -0,0 +1,343 @@
+#ifndef _ImageIO_h
+#define _ImageIO_h
+
+#include "cv.h"
+#include "highgui.h"
+
+using namespace cv;
+
+class ImageIO
+{
+public:
+	enum ImageType{standard, derivative, normalized};
+	ImageIO(void);
+	~ImageIO(void);
+public:
+	template <class T>
+	static bool loadImage(const char* filename,T*& pImagePlane,int& width,int& height, int& nchannels);
+	template <class T>
+	static bool saveImage(const char* filename,const T* pImagePlane,int width,int height, int nchannels,ImageType imtype = standard);
+
+};
+
+template <class T>
+bool ImageIO::loadImage(const char *filename, T *&pImagePlane, int &width, int &height, int &nchannels)
+{
+	Mat im = imread(filename);
+	if(im.data == NULL) // if allocation fails
+		return false;
+	if(im.type()!=CV_8UC1 && im.type()!=CV_8UC3 && im.type()!=CV_8UC4) // we only support three types of image information for now
+		return false;
+	width = im.size().width;
+	height = im.size().height;
+	nchannels = im.channels();
+	pImagePlane = new T[width*height*nchannels];
+
+	if(typeid(T) == typeid(unsigned char))
+	{
+		for(int i = 0;i<height;i++)
+			memcpy(pImagePlane+i*im.step,im.data+i*im.step,width*nchannels);
+		return true;
+	}
+
+	// check whether the type is float point
+	bool IsFloat=false;
+	if(typeid(T)==typeid(double) || typeid(T)==typeid(float) || typeid(T)==typeid(long double))
+		IsFloat=true;
+	
+	for(int i =0;i<height;i++)
+	{
+		int offset1 = i*width*nchannels;
+		int offset2 = i*im.step;
+		for(int j=0;j<im.step;j++)
+		{
+			if(IsFloat)
+				pImagePlane[offset1+j] = (T)im.data[offset2+j]/255;
+			else
+				pImagePlane[offset1+j] = im.data[offset2+j];
+		}
+	}
+	return true;
+}
+
+template <class T>
+bool ImageIO::saveImage(const char* filename,const T* pImagePlane,int width,int height, int nchannels,ImageType imtype)
+{
+	Mat im;
+	switch(nchannels){
+		case 1:
+			im.create(height,width,CV_8UC1);
+			break;
+		case 3:
+			im.create(height,width,CV_8UC3);
+			break;
+		default:
+			return -1;
+	}
+	// check whether the type is float point
+	bool IsFloat=false;
+	if(typeid(T)==typeid(double) || typeid(T)==typeid(float) || typeid(T)==typeid(long double))
+		IsFloat=true;
+
+	T Max,Min;
+	int nElements = width*height*nchannels;
+	switch(imtype){
+		case standard:
+			break;
+		case derivative:
+			// find the max of the absolute value
+			Max = pImagePlane[0];
+			if(!IsFloat)
+				for(int i = 0;i<nElements;i++)
+					Max = __max(Max,abs(pImagePlane[i]));
+			else
+				for(int i=0;i<nElements;i++)
+					Max = __max(Max,fabs((double)pImagePlane[i]));
+			Max*=2;
+			break;
+		case normalized:
+			Max = Min = pImagePlane[0];
+			for(int i = 0;i<nElements;i++)
+			{
+				Max = __max(Max,pImagePlane[i]);
+				Min = __min(Min,pImagePlane[i]);
+			}
+			break;
+	}
+	if(typeid(T) == typeid(unsigned char) && imtype == standard)
+	{
+		for(int i = 0;i<height;i++)
+			memcpy(im.data+i*im.step,pImagePlane+i*im.step,width*nchannels);
+	}
+	else
+	{
+		for(int i =0;i<height;i++)
+		{
+			int offset1 = i*width*nchannels;
+			int offset2 = i*im.step;
+			for(int j=0;j<im.step;j++)
+			{
+				switch(imtype){
+					case standard:
+						if(IsFloat)
+							im.data[offset2+j] = pImagePlane[offset1+j]*255;
+						else
+							im.data[offset2+j] = pImagePlane[offset1+j];
+						break;
+					case derivative:
+						
+						if(IsFloat)
+							im.data[offset2+j] = (double)(pImagePlane[offset1+j]/Max+0.5)*255;
+						else
+							im.data[offset2+j] = ((double)pImagePlane[offset1+j]/Max+0.5)*255;
+						break;
+					case normalized:
+						im.data[offset2+j] = (double)(pImagePlane[offset1+j]-Min)/(Max-Min)*255;
+						break;
+				}
+			}
+		}
+	}
+	return imwrite(filename,im);
+}
+
+
+
+/*
+#include <QVector>
+#include <QImage>
+#include <QString>
+#include "math.h"
+//-----------------------------------------------------------------------------------------
+// this class is a wrapper to use QImage to load image into image planes
+//-----------------------------------------------------------------------------------------
+
+class ImageIO
+{
+public:
+	enum ImageType{standard, derivative, normalized};
+	ImageIO(void);
+	~ImageIO(void);
+public:
+	template <class T>
+	static void loadImage(const QImage& image,T*& pImagePlane,int& width,int& height,int& nchannels);
+	template <class T>
+	static bool loadImage(const QString& filename,T*& pImagePlane,int& width,int& height,int& nchannels);
+
+	template <class T>
+	static unsigned char convertPixel(const T& value,bool IsFloat,ImageType type,T& _Max,T& _Min);
+
+	template <class T>
+	static bool writeImage(const QString& filename, const T*& pImagePlane,int width,int height,int nchannels,ImageType type=standard,int quality=-1);
+
+	template <class T>
+	static bool writeImage(const QString& filename,const T* pImagePlane,int width,int height,int nchannels,T min, T max,int quality=-1);
+
+};
+
+template <class T>
+void ImageIO::loadImage(const QImage& image, T*& pImagePlane,int& width,int& height,int& nchannels)
+{
+	// get the image information
+	width=image.width();
+	height=image.height();
+	nchannels=3;
+	pImagePlane=new T[width*height*nchannels];
+
+	// check whether the type is float point
+	bool IsFloat=false;
+	if(typeid(T)==typeid(double) || typeid(T)==typeid(float) || typeid(T)==typeid(long double))
+		IsFloat=true;
+
+	const unsigned char* plinebuffer;
+	for(int i=0;i<height;i++)
+	{
+		plinebuffer=image.scanLine(i);
+		for(int j=0;j<width;j++)
+		{
+			if(IsFloat)
+			{
+				pImagePlane[(i*width+j)*3]=(T)plinebuffer[j*4]/255;
+				pImagePlane[(i*width+j)*3+1]=(T)plinebuffer[j*4+1]/255;
+				pImagePlane[(i*width+j)*3+2]=(T)plinebuffer[j*4+2]/255;
+			}
+			else
+			{
+				pImagePlane[(i*width+j)*3]=plinebuffer[j*4];
+				pImagePlane[(i*width+j)*3+1]=plinebuffer[j*4+1];
+				pImagePlane[(i*width+j)*3+2]=plinebuffer[j*4+2];
+			}
+		}
+	}
+}
+
+template <class T>
+bool ImageIO::loadImage(const QString&filename, T*& pImagePlane,int& width,int& height,int& nchannels)
+{
+	QImage image;
+	if(image.load(filename)==false)
+		return false;
+	if(image.format()!=QImage::Format_RGB32)
+	{
+		QImage temp=image.convertToFormat(QImage::Format_RGB32);
+		image=temp;
+	}
+	loadImage(image,pImagePlane,width,height,nchannels);
+	return true;
+}
+
+template <class T>
+bool ImageIO::writeImage(const QString& filename, const T*& pImagePlane,int width,int height,int nchannels,ImageType type,int quality)
+{
+	int nPixels=width*height,nElements;
+	nElements=nPixels*nchannels;
+	unsigned char* pTempBuffer;
+	pTempBuffer=new unsigned char[nPixels*4];
+	memset(pTempBuffer,0,nPixels*4);
+
+	// check whether the type is float point
+	bool IsFloat=false;
+	if(typeid(T)==typeid(double) || typeid(T)==typeid(float) || typeid(T)==typeid(long double))
+		IsFloat=true;
+
+	T _Max=0,_Min=0;
+	switch(type){
+		case standard:
+			break;
+		case derivative:
+			_Max=0;
+			for(int i=0;i<nPixels;i++)
+			{
+				if(IsFloat)
+					_Max=__max(_Max,fabs((double)pImagePlane[i]));
+				else
+					_Max=__max(_Max,abs(pImagePlane[i]));
+			}
+			break;
+		case normalized:
+			_Min=_Max=pImagePlane[0];
+			for(int i=1;i<nElements;i++)
+			{
+				_Min=__min(_Min,pImagePlane[i]);
+				_Max=__max(_Max,pImagePlane[i]);
+			}
+			break;
+	}
+
+	for(int i=0;i<nPixels;i++)
+	{
+		if(nchannels>=3)
+		{
+			pTempBuffer[i*4]=convertPixel(pImagePlane[i*nchannels],IsFloat,type,_Max,_Min);
+			pTempBuffer[i*4+1]=convertPixel(pImagePlane[i*nchannels+1],IsFloat,type,_Max,_Min);
+			pTempBuffer[i*4+2]=convertPixel(pImagePlane[i*nchannels+2],IsFloat,type,_Max,_Min);
+		}
+		else 
+			for (int j=0;j<3;j++)
+				pTempBuffer[i*4+j]=convertPixel(pImagePlane[i*nchannels],IsFloat,type,_Max,_Min);
+		pTempBuffer[i*4+3]=255;
+	}
+	QImage *pQImage=new QImage(pTempBuffer,width,height,QImage::Format_RGB32);
+	bool result= pQImage->save(filename,0,quality);
+	delete pQImage;
+	delete pTempBuffer;
+	return result;
+}
+
+template <class T>
+bool ImageIO::writeImage(const QString& filename, const T* pImagePlane,int width,int height,int nchannels,T min,T max,int quality)
+{
+	int nPixels=width*height,nElements;
+	nElements=nPixels*nchannels;
+	unsigned char* pTempBuffer;
+	pTempBuffer=new unsigned char[nPixels*4];
+	memset(pTempBuffer,0,nPixels*4);
+
+	// check whether the type is float point
+	bool IsFloat=false;
+	if(typeid(T)==typeid(double) || typeid(T)==typeid(float) || typeid(T)==typeid(long double))
+		IsFloat=true;
+
+	T _Max=max,_Min=min;
+
+	for(int i=0;i<nPixels;i++)
+	{
+		if(nchannels>=3)
+		{
+			pTempBuffer[i*4]=convertPixel(pImagePlane[i*nchannels],IsFloat,normalized,_Max,_Min);
+			pTempBuffer[i*4+1]=convertPixel(pImagePlane[i*nchannels+1],IsFloat,normalized,_Max,_Min);
+			pTempBuffer[i*4+2]=convertPixel(pImagePlane[i*nchannels+2],IsFloat,normalized,_Max,_Min);
+		}
+		else 
+			for (int j=0;j<3;j++)
+				pTempBuffer[i*4+j]=convertPixel(pImagePlane[i*nchannels],IsFloat,normalized,_Max,_Min);
+		pTempBuffer[i*4+3]=255;
+	}
+	QImage *pQImage=new QImage(pTempBuffer,width,height,QImage::Format_RGB32);
+	bool result= pQImage->save(filename,0,quality);
+	delete pQImage;
+	delete pTempBuffer;
+	return result;
+}
+
+template <class T>
+unsigned char ImageIO::convertPixel(const T& value,bool IsFloat,ImageType type,T& _Max,T& _Min)
+{
+	switch(type){
+		case standard:
+			if(IsFloat)
+				return __max(__min(value*255,255),0);
+			else
+				return __max(__min(value,255),0);
+			break;
+		case derivative:
+			return (double)((double)value/_Max+1)/2*255;
+			break;
+		case normalized:
+			return (double)(value-_Min)/(_Max-_Min)*255;
+			break;
+	}
+	return 0;
+}
+//*/
+#endif

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/ImageProcessing.h

@@ -0,0 +1,414 @@
+#ifndef _ImageProcessing_h
+#define _ImageProcessing_h
+
+#include "math.h"
+#include "stdio.h"
+#include "stdlib.h"
+#include <typeinfo>
+
+//----------------------------------------------------------------------------------
+// class to handle basic image processing functions
+// this is a collection of template functions. These template functions are
+// used in other image classes such as BiImage, IntImage and FImage 
+//----------------------------------------------------------------------------------
+
+class ImageProcessing
+{
+public:
+	ImageProcessing(void);
+	~ImageProcessing(void);
+public:
+	// basic functions
+	template <class T>
+	static inline T EnforceRange(const T& x,const int& MaxValue) {return __min(__max(x,0),MaxValue-1);};
+
+	//---------------------------------------------------------------------------------
+	// function to interpolate the image plane
+	//---------------------------------------------------------------------------------
+	template <class T1,class T2> 
+	static inline void BilinearInterpolate(const T1* pImage,int width,int height,int nChannels,double x,double y,T2* result);
+
+	template <class T1>
+	static inline T1 BilinearInterpolate(const T1* pImage,int width,int height,double x,double y);
+
+	template <class T1,class T2>
+	static void ResizeImage(const T1* pSrcImage,T2* pDstImage,int SrcWidth,int SrcHeight,int nChannels,double Ratio);
+
+	template <class T1,class T2>
+	static void ResizeImage(const T1* pSrcImage,T2* pDstImage,int SrcWidth,int SrcHeight,int nChannels,int DstWidth,int DstHeight);
+
+	//---------------------------------------------------------------------------------
+	// functions for 1D filtering
+	//---------------------------------------------------------------------------------
+	template <class T1,class T2>
+	static void hfiltering(const T1* pSrcImage,T2* pDstImage,int width,int height,int nChannels,double* pfilter1D,int fsize);
+
+	template <class T1,class T2>
+	static void vfiltering(const T1* pSrcImage,T2* pDstImage,int width,int height,int nChannels,double* pfilter1D,int fsize);
+
+	//---------------------------------------------------------------------------------
+	// functions for 2D filtering
+	//---------------------------------------------------------------------------------
+	template <class T1,class T2>
+	static void filtering(const T1* pSrcImage,T2* pDstImage,int width,int height,int nChannels,double* pfilter2D,int fsize);
+
+	template <class T1,class T2>
+	static void Laplacian(const T1* pSrcImage,T2* pDstImage,int width,int height,int nChannels);
+
+	//---------------------------------------------------------------------------------
+	// functions for sample a patch from the image
+	//---------------------------------------------------------------------------------
+	template <class T1,class T2>
+	static void getPatch(const T1* pSrcImgae,T2* pPatch,int width,int height,int nChannels,double x,double y,int wsize);
+	
+	//---------------------------------------------------------------------------------
+	// function to warp image
+	//---------------------------------------------------------------------------------
+	template <class T1,class T2>
+	static void warpImage(T1* pWarpIm2,const T1* pIm1,const T1* pIm2,const T2* pVx,const T2* pVy,int width,int height,int nChannels);
+
+	template <class T1,class T2,class T3>
+	static void warpImage(T1 *pWarpIm2, T3* pMask,const T1 *pIm1, const T1 *pIm2, const T2 *pVx, const T2 *pVy, int width, int height, int nChannels);
+
+
+	//---------------------------------------------------------------------------------
+	// function to crop an image
+	//---------------------------------------------------------------------------------
+	template <class T1,class T2>
+	static void cropImage(const T1* pSrcImage,int SrcWidth,int SrcHeight,int nChannels,T2* pDstImage,int Left,int Top,int DstWidth,int DstHeight);
+	//---------------------------------------------------------------------------------
+
+	//---------------------------------------------------------------------------------
+	// function to generate a 2D Gaussian 
+	//---------------------------------------------------------------------------------
+	template <class T>
+	static void generate2DGaussian(T*& pImage,int wsize,double sigma=-1);
+};
+
+//--------------------------------------------------------------------------------------------------
+// function to interplate multi-channel image plane for (x,y)
+// --------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+inline void ImageProcessing::BilinearInterpolate(const T1* pImage,int width,int height,int nChannels,double x,double y,T2* result)
+{
+	int xx,yy,m,n,u,v,l,offset;
+	xx=x;
+	yy=y;
+	double dx,dy,s;
+	dx=__max(__min(x-xx,1),0);
+	dy=__max(__min(y-yy,1),0);
+
+	memset(result,0,sizeof(T2)*nChannels);
+
+	for(m=0;m<=1;m++)
+		for(n=0;n<=1;n++)
+		{
+			u=EnforceRange(xx+m,width);
+			v=EnforceRange(yy+n,height);
+			offset=(v*width+u)*nChannels;
+			s=fabs(1-m-dx)*fabs(1-n-dy);
+			for(l=0;l<nChannels;l++)
+				result[l]+=pImage[offset+l]*s;
+		}
+}
+
+template <class T1>
+inline T1 ImageProcessing::BilinearInterpolate(const T1* pImage,int width,int height,double x,double y)
+{
+	int xx,yy,m,n,u,v,l,offset;
+	xx=x;
+	yy=y;
+	double dx,dy,s;
+	dx=__max(__min(x-xx,1),0);
+	dy=__max(__min(y-yy,1),0);
+
+	T1 result=0;
+	for(m=0;m<=1;m++)
+		for(n=0;n<=1;n++)
+		{
+			u=EnforceRange(xx+m,width);
+			v=EnforceRange(yy+n,height);
+			offset=v*width+u;
+			s=fabs(1-m-dx)*fabs(1-n-dy);
+			result+=pImage[offset]*s;
+		}
+	return result;
+}
+//------------------------------------------------------------------------------------------------------------
+// this is the most general function for reszing an image with a varying nChannels
+// bilinear interpolation is used for now. It might be replaced by other (bicubic) interpolation methods 
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::ResizeImage(const T1* pSrcImage,T2* pDstImage,int SrcWidth,int SrcHeight,int nChannels,double Ratio)
+{
+	int DstWidth,DstHeight;
+	DstWidth=(double)SrcWidth*Ratio;
+	DstHeight=(double)SrcHeight*Ratio;
+	memset(pDstImage,sizeof(T2)*DstWidth*DstHeight*nChannels,0);
+	
+	double x,y;
+
+	for(int i=0;i<DstHeight;i++)
+		for(int j=0;j<DstWidth;j++)
+		{
+			x=(double)(j+1)/Ratio-1;
+			y=(double)(i+1)/Ratio-1;
+
+			// bilinear interpolation
+			BilinearInterpolate(pSrcImage,SrcWidth,SrcHeight,nChannels,x,y,pDstImage+(i*DstWidth+j)*nChannels);
+		}
+}
+
+template <class T1,class T2>
+void ImageProcessing::ResizeImage(const T1 *pSrcImage, T2 *pDstImage, int SrcWidth, int SrcHeight, int nChannels, int DstWidth, int DstHeight)
+{
+	double xRatio=(double)DstWidth/SrcWidth;
+	double yRatio=(double)DstHeight/SrcHeight;
+	memset(pDstImage,sizeof(T2)*DstWidth*DstHeight*nChannels,0);
+
+	double x,y;
+
+	for(int i=0;i<DstHeight;i++)
+		for(int j=0;j<DstWidth;j++)
+		{
+			x=(double)(j+1)/xRatio-1;
+			y=(double)(i+1)/yRatio-1;
+
+			// bilinear interpolation
+			BilinearInterpolate(pSrcImage,SrcWidth,SrcHeight,nChannels,x,y,pDstImage+(i*DstWidth+j)*nChannels);
+		}
+}
+
+//------------------------------------------------------------------------------------------------------------
+//  horizontal direction filtering
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::hfiltering(const T1* pSrcImage,T2* pDstImage,int width,int height,int nChannels,double* pfilter1D,int fsize)
+{
+	memset(pDstImage,0,sizeof(T2)*width*height*nChannels);
+	T2* pBuffer;
+	double w;
+	int i,j,l,k,offset,jj;
+	for(i=0;i<height;i++)
+		for(j=0;j<width;j++)
+		{
+			offset=i*width*nChannels;
+			pBuffer=pDstImage+offset+j*nChannels;
+			for(l=-fsize;l<=fsize;l++)
+			{
+				w=pfilter1D[l+fsize];
+				jj=EnforceRange(j+l,width);
+				for(k=0;k<nChannels;k++)
+					pBuffer[k]+=pSrcImage[offset+jj*nChannels+k]*w;
+			}
+		}
+}
+
+//------------------------------------------------------------------------------------------------------------
+// fast filtering algorithm for laplacian
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::Laplacian(const T1 *pSrcImage, T2 *pDstImage, int width, int height, int nChannels)
+{
+	int LineWidth=width*nChannels;
+	int nElements=width*height*nChannels;
+	// first treat the corners
+	for(int k=0;k<nChannels;k++)
+	{
+		pDstImage[k]=pSrcImage[k]*2-pSrcImage[nChannels+k]-pSrcImage[LineWidth+k];
+		pDstImage[LineWidth-nChannels+k]=pSrcImage[LineWidth-nChannels+k]*2-pSrcImage[LineWidth-2*nChannels+k]-pSrcImage[2*LineWidth-nChannels+k];
+		pDstImage[nElements-LineWidth+k]=pSrcImage[nElements-LineWidth+k]*2-pSrcImage[nElements-LineWidth+nChannels+k]-pSrcImage[nElements-2*LineWidth+k];
+		pDstImage[nElements-nChannels+k]=pSrcImage[nElements-nChannels+k]*2-pSrcImage[nElements-2*nChannels+k]-pSrcImage[nElements-LineWidth-nChannels+k];
+	}
+	// then treat the borders
+	for(int i=1;i<width-1;i++)
+		for(int k=0;k<nChannels;k++)
+		{
+			pDstImage[i*nChannels+k]=pSrcImage[i*nChannels+k]*3-pSrcImage[(i-1)*nChannels+k]-pSrcImage[(i+1)*nChannels+k]-pSrcImage[i*nChannels+LineWidth+k];
+			pDstImage[nElements-LineWidth+i*nChannels+k]=pSrcImage[nElements-LineWidth+i*nChannels+k]*3-pSrcImage[nElements-LineWidth+(i-1)*nChannels+k]-pSrcImage[nElements-LineWidth+(i+1)*nChannels+k]-pSrcImage[nElements-2*LineWidth+i*nChannels+k];
+		}
+	for(int i=1;i<height-1;i++)
+		for(int k=0;k<nChannels;k++)
+		{
+			pDstImage[i*LineWidth+k]=pSrcImage[i*LineWidth+k]*3-pSrcImage[i*LineWidth+nChannels+k]-pSrcImage[(i-1)*LineWidth+k]-pSrcImage[(i+1)*LineWidth+k];
+			pDstImage[(i+1)*LineWidth-nChannels+k]=pSrcImage[(i+1)*LineWidth-nChannels+k]*3-pSrcImage[(i+1)*LineWidth-2*nChannels+k]-pSrcImage[i*LineWidth-nChannels+k]-pSrcImage[(i+2)*LineWidth-nChannels+k];
+		}
+	// now the interior
+	for(int i=1;i<height-1;i++)
+		for(int j=1;j<width-1;j++)
+		{
+			int offset=(i*width+j)*nChannels;
+			for(int k=0;k<nChannels;k++)
+				pDstImage[offset+k]=pSrcImage[offset+k]*4-pSrcImage[offset+nChannels+k]-pSrcImage[offset-nChannels+k]-pSrcImage[offset-LineWidth+k]-pSrcImage[offset+LineWidth+k];
+		}
+}
+
+
+//------------------------------------------------------------------------------------------------------------
+// vertical direction filtering
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::vfiltering(const T1* pSrcImage,T2* pDstImage,int width,int height,int nChannels,double* pfilter1D,int fsize)
+{
+	memset(pDstImage,0,sizeof(T2)*width*height*nChannels);
+	T2* pBuffer;
+	double w;
+	int i,j,l,k,offset,ii;
+	for(i=0;i<height;i++)
+		for(j=0;j<width;j++)
+		{
+			pBuffer=pDstImage+(i*width+j)*nChannels;
+			for(l=-fsize;l<=fsize;l++)
+			{
+				w=pfilter1D[l+fsize];
+				ii=EnforceRange(i+l,height);
+				for(k=0;k<nChannels;k++)
+					pBuffer[k]+=pSrcImage[(ii*width+j)*nChannels+k]*w;
+			}
+		}
+}
+
+//------------------------------------------------------------------------------------------------------------
+// 2d filtering
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::filtering(const T1* pSrcImage,T2* pDstImage,int width,int height,int nChannels,double* pfilter2D,int fsize)
+{
+	double w;
+	int i,j,u,v,k,ii,jj,wsize,offset;
+	wsize=fsize*2+1;
+	double* pBuffer=new double[nChannels];
+	for(i=0;i<height;i++)
+		for(j=0;j<width;j++)
+		{
+			for(k=0;k<nChannels;k++)
+				pBuffer[k]=0;
+			for(u=-fsize;u<=fsize;u++)
+				for(v=-fsize;v<=fsize;v++)
+				{
+					w=pfilter2D[(u+fsize)*wsize+v+fsize];
+					ii=EnforceRange(i+u,height);
+					jj=EnforceRange(j+v,width);
+					offset=(ii*width+jj)*nChannels;
+					for(k=0;k<nChannels;k++)
+						pBuffer[k]+=pSrcImage[offset+k]*w;
+				}
+			offset=(i*width+j)*nChannels;
+			for(k=0;k<nChannels;k++)
+				pDstImage[offset+k]=pBuffer[k];
+		}
+	delete pBuffer;
+}
+
+//------------------------------------------------------------------------------------------------------------
+// function to sample a patch from the source image
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::getPatch(const T1* pSrcImage,T2* pPatch,int width,int height,int nChannels,double x0,double y0,int wsize)
+{
+	// suppose pPatch has been allocated and cleared before calling the function
+	int wlength=wsize*2+1;
+	double x,y;
+	for(int i=-wsize;i<=wsize;i++)
+		for(int j=-wsize;j<=wsize;j++)
+		{
+			y=y0+i;
+			x=x0+j;
+			if(x<0 || x>width-1 || y<0 || y>height-1)
+				continue;
+			BilinearInterpolate(pSrcImage,width,height,nChannels,x,y,pPatch+((i+wsize)*wlength+j+wsize)*nChannels);
+		}
+}
+
+//------------------------------------------------------------------------------------------------------------
+// function to warp an image with respect to flow field
+// pWarpIm2 has to be allocated before hands
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::warpImage(T1 *pWarpIm2, const T1 *pIm1, const T1 *pIm2, const T2 *pVx, const T2 *pVy, int width, int height, int nChannels)
+{
+	for(int i=0;i<height;i++)
+		for(int j=0;j<width;j++)
+		{
+			int offset=i*width+j;
+			double x,y;
+			y=i+pVy[offset];
+			x=j+pVx[offset];
+			offset*=nChannels;
+			if(x<0 || x>width-1 || y<0 || y>height-1)
+			{
+				for(int k=0;k<nChannels;k++)
+					pWarpIm2[offset+k]=pIm1[offset+k];
+				continue;
+			}
+			BilinearInterpolate(pIm2,width,height,nChannels,x,y,pWarpIm2+offset);
+		}
+}
+
+template <class T1,class T2,class T3>
+void ImageProcessing::warpImage(T1 *pWarpIm2, T3* pMask,const T1 *pIm1, const T1 *pIm2, const T2 *pVx, const T2 *pVy, int width, int height, int nChannels)
+{
+	for(int i=0;i<height;i++)
+		for(int j=0;j<width;j++)
+		{
+			int offset=i*width+j;
+			double x,y;
+			y=i+pVy[offset];
+			x=j+pVx[offset];
+			offset*=nChannels;
+			if(x<0 || x>width-1 || y<0 || y>height-1)
+			{
+				for(int k=0;k<nChannels;k++)
+					pWarpIm2[offset+k]=pIm1[offset+k];
+				pMask[i*width+j]=0;
+				continue;
+			}
+			pMask[i*width+j]=1;
+			BilinearInterpolate(pIm2,width,height,nChannels,x,y,pWarpIm2+offset);
+		}
+}
+
+//------------------------------------------------------------------------------------------------------------
+// function to crop an image from the source
+// assume that pDstImage has been allocated
+// also Left and Top must be valid, DstWidth and DstHeight should ensure that the image lies
+// inside the image boundary
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::cropImage(const T1 *pSrcImage, int SrcWidth, int SrcHeight, int nChannels, T2 *pDstImage, int Left, int Top, int DstWidth, int DstHeight)
+{
+	if(typeid(T1)==typeid(T2))
+	{
+		for(int i=0;i<DstHeight;i++)
+			memcpy(pDstImage+i*DstWidth*nChannels,pSrcImage+((i+Top)*SrcWidth+Left)*nChannels,sizeof(T1)*DstWidth*nChannels);
+		return;
+	}
+	int offsetSrc,offsetDst;
+	for(int i=0;i<DstHeight;i++)
+		for(int j=0;j<DstWidth;j++)
+		{
+			offsetSrc=((i+Top)*SrcWidth+Left+j)*nChannels;
+			offsetDst=(i*DstWidth+j)*nChannels;
+			for(int k=0;k<nChannels;k++)
+				pDstImage[offsetDst+k]=pSrcImage[offsetSrc+k];
+		}
+}
+
+//------------------------------------------------------------------------------------------------------------
+// function to generate a 2D Gaussian image
+// pImage must be allocated before calling the function
+//------------------------------------------------------------------------------------------------------------
+template <class T>
+void ImageProcessing::generate2DGaussian(T*& pImage, int wsize, double sigma)
+{
+	if(sigma==-1)
+		sigma=wsize;
+	double alpha=1/(2*sigma*sigma);
+	int winlength=wsize*2+1;
+	if(pImage==NULL)
+		pImage=new T[winlength*winlength];
+	for(int i=-wsize;i<=wsize;i++)
+		for(int j=-wsize;j<=wsize;j++)
+			pImage[(i+wsize)*winlength+j+wsize]=exp(-(double)(i*i+j*j)*alpha);
+}
+#endif

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/Matrix.cpp

@@ -0,0 +1,419 @@
+#include "Matrix.h"
+#include "memory.h"
+#include <iostream>
+
+using namespace std;
+
+bool Matrix::IsDispInfo=false;
+
+Matrix::Matrix(void)
+{
+	nRow=nCol=0;
+	pData=NULL;
+}
+
+Matrix::Matrix(int nrow,int ncol,double* data)
+{
+	nRow=nrow;
+	nCol=ncol;
+	pData=new double[nRow*nCol];
+	if(data==NULL)
+		memset(pData,0,sizeof(double)*nRow*nCol);
+	else
+		memcpy(pData,data,sizeof(double)*nRow*nCol);
+}
+
+Matrix::Matrix(const Matrix& matrix)
+{
+	nRow=nCol=0;
+	pData=NULL;
+	copyData(matrix);
+}
+
+Matrix::~Matrix(void)
+{
+	releaseData();
+}
+
+void Matrix::releaseData()
+{
+	if(pData!=NULL)
+		delete pData;
+	pData=NULL;
+	nRow=nCol=0;
+}
+
+void Matrix::copyData(const Matrix &matrix)
+{
+	if(!dimMatch(matrix))
+		allocate(matrix);
+	memcpy(pData,matrix.pData,sizeof(double)*nRow*nCol);
+}
+
+bool Matrix::dimMatch(const Matrix& matrix) const
+{
+	if(nCol==matrix.nCol && nRow==matrix.nRow)
+		return true;
+	else
+		return false;
+}
+
+bool Matrix::dimcheck(const Matrix& matrix) const
+{
+	if(!dimMatch(matrix))
+	{
+		cout<<"The dimensions of the matrices don't match!"<<endl;
+		return false;
+	}
+	return true;
+}
+
+void Matrix::reset()
+{
+	if(pData!=NULL)
+		memset(pData,0,sizeof(double)*nRow*nCol);
+}
+
+void Matrix::allocate(int nrow,int ncol)
+{
+	releaseData();
+	nRow=nrow;
+	nCol=ncol;
+	if(nRow*nCol>0)
+		pData=new double[nRow*nCol];
+}
+
+void Matrix::allocate(const Matrix& matrix)
+{
+	allocate(matrix.nRow,matrix.nCol);
+}
+
+void Matrix::loadData(int _nrow, int _ncol, double *data)
+{
+	if(!matchDimension(_nrow,_ncol))
+		allocate(_nrow,_ncol);
+	memcpy(pData,data,sizeof(double)*nRow*nCol);
+}
+
+void Matrix::printMatrix()
+{
+	for(int i=0;i<nRow;i++)
+	{
+		for(int j=0;j<nCol;j++)
+			cout<<pData[i*nCol+j]<<" ";
+		cout<<endl;
+	}
+}
+
+void Matrix::identity(int ndim)
+{
+	allocate(ndim,ndim);
+	reset();
+	for(int i=0;i<ndim;i++)
+		pData[i*ndim+i]=1;
+}
+
+//--------------------------------------------------------------------------------------------------
+// functions to check dimensionalities
+//--------------------------------------------------------------------------------------------------
+bool Matrix::checkDimRight(const Vector& vect) const
+{
+	if(nCol==vect.dim())
+		return true;
+	else
+	{
+		cout<<"The matrix and vector don't match in multiplication!"<<endl;
+		return false;
+	}
+}
+
+bool Matrix::checkDimRight(const Matrix &matrix) const
+{
+	if(nCol==matrix.nrow())
+		return true;
+	else
+	{
+		cout<<"The matrix and matrix don't match in multiplication!"<<endl;
+		return false;
+	}
+}
+
+bool Matrix::checkDimLeft(const Vector& vect) const
+{
+	if(nRow==vect.dim())
+		return true;
+	else
+	{
+		cout<<"The vector and matrix don't match in multiplication!"<<endl;
+		return false;
+	}
+}
+
+bool Matrix::checkDimLeft(const Matrix &matrix) const
+{
+	if(nRow==matrix.ncol())
+		return true;
+	else
+	{
+		cout<<"The matrix and matrix don't match in multiplication!"<<endl;
+		return false;
+	}
+}
+
+//--------------------------------------------------------------------------------------------------
+// functions for numerical computation
+//--------------------------------------------------------------------------------------------------
+void Matrix::Multiply(Vector &result, const Vector &vect) const
+{
+	checkDimRight(vect);
+	if(result.dim()!=nRow)
+		result.allocate(nRow);
+	for(int i=0;i<nRow;i++)
+	{
+		double temp=0;
+		for(int j=0;j<nCol;j++)
+			temp+=pData[i*nCol+j]*vect.data()[j];
+		result.data()[i]=temp;
+	}
+}
+
+void Matrix::Multiply(Matrix &result, const Matrix &matrix) const
+{
+	checkDimRight(matrix);
+	if(!result.matchDimension(nRow,matrix.nCol))
+		result.allocate(nRow,matrix.nCol);
+	for(int i=0;i<nRow;i++)
+		for(int j=0;j<matrix.nCol;j++)
+		{
+			double temp=0;
+			for(int k=0;k<nCol;k++)
+				temp+=pData[i*nCol+k]*matrix.pData[k*matrix.nCol+j];
+			result.pData[i*matrix.nCol+j]=temp;
+		}
+}
+
+void Matrix::transpose(Matrix &result) const
+{
+	if(!result.matchDimension(nCol,nRow))
+		result.allocate(nCol,nRow);
+	for(int i=0;i<nCol;i++)
+		for(int j=0;j<nRow;j++)
+			result.pData[i*nRow+j]=pData[j*nCol+i];
+}
+
+void Matrix::fromVector(const Vector &vect)
+{
+	if(!matchDimension(vect.dim(),1))
+		allocate(vect.dim(),1);
+	memcpy(pData,vect.data(),sizeof(double)*vect.dim());
+}
+
+double Matrix::norm2() const
+{
+	if(pData==NULL)
+		return 0;
+	double temp=0;
+	for(int i=0;i<nCol*nRow;i++)
+		temp+=pData[i]*pData[i];
+	return temp;
+}
+
+//--------------------------------------------------------------------------------------------------
+// operators
+//--------------------------------------------------------------------------------------------------
+Matrix& Matrix::operator=(const Matrix& matrix)
+{
+	copyData(matrix);
+	return *this;
+}
+
+Matrix& Matrix::operator +=(double val)
+{
+	for(int i=0;i<nCol*nRow;i++)
+		pData[i]+=val;
+	return *this;
+}
+
+Matrix& Matrix::operator -=(double val)
+{
+	for(int i=0;i<nCol*nRow;i++)
+		pData[i]-=val;
+	return *this;
+}
+
+Matrix& Matrix::operator *=(double val)
+{
+	for(int i=0;i<nCol*nRow;i++)
+		pData[i]*=val;
+	return *this;
+}
+
+Matrix& Matrix::operator /=(double val)
+{
+	for(int i=0;i<nCol*nRow;i++)
+		pData[i]/=val;
+	return *this;
+}
+
+Matrix& Matrix::operator +=(const Matrix &matrix)
+{
+	dimcheck(matrix);
+	for(int i=0;i<nCol*nRow;i++)
+		pData[i]+=matrix.pData[i];
+	return *this;
+}
+
+Matrix& Matrix::operator -=(const Matrix &matrix)
+{
+	dimcheck(matrix);
+	for(int i=0;i<nCol*nRow;i++)
+		pData[i]-=matrix.pData[i];
+	return *this;
+}
+
+Matrix& Matrix::operator *=(const Matrix &matrix)
+{
+	dimcheck(matrix);
+	for(int i=0;i<nCol*nRow;i++)
+		pData[i]*=matrix.pData[i];
+	return *this;
+}
+
+Matrix& Matrix::operator /=(const Matrix &matrix)
+{
+	dimcheck(matrix);
+	for(int i=0;i<nCol*nRow;i++)
+		pData[i]/=matrix.pData[i];
+	return *this;
+}
+
+Vector operator*(const Matrix& matrix,const Vector& vect)
+{
+	Vector result;
+	matrix.Multiply(result,vect);
+	return result;
+}
+
+Matrix operator*(const Matrix& matrix1,const Matrix& matrix2)
+{
+	Matrix result;
+	matrix1.Multiply(result,matrix2);
+	return result;
+}
+
+//--------------------------------------------------------------------------------------------------
+// function for conjugate gradient method
+//--------------------------------------------------------------------------------------------------
+void Matrix::ConjugateGradient(Vector &result, const Vector &b) const
+{
+	if(nCol!=nRow)
+	{
+		cout<<"Error: when solving Ax=b, A is not square!"<<endl;
+		return;
+	}
+	checkDimRight(b);
+	if(!result.matchDimension(b))
+		result.allocate(b);
+
+	Vector r(b),p,q;
+	result.reset();
+
+	int nIterations=nRow*5;
+	Vector rou(nIterations);
+	for(int k=0;k<nIterations;k++)
+	{
+		rou[k]=r.norm2();
+		if(IsDispInfo)
+			cout<<rou[k]<<endl;
+
+		if(rou[k]<1E-20)
+			break;
+		if(k==0)
+			p=r;
+		else
+		{
+			double ratio=rou[k]/rou[k-1];
+			p=r+p*ratio;
+		}
+		Multiply(q,p);
+		double alpha=rou[k]/innerproduct(p,q);
+		result+=p*alpha;
+		r-=q*alpha;
+	}
+}
+
+void Matrix::SolveLinearSystem(Vector &result, const Vector &b) const
+{
+	if(nCol==nRow)
+	{
+		ConjugateGradient(result,b);
+		return;
+	}
+	if(nRow<nCol)
+	{
+		cout<<"Not enough observations for parameter estimation!"<<endl;
+		return;
+	}
+	Matrix AT,ATA;
+	transpose(AT);
+	AT.Multiply(ATA,*this);
+	Vector ATb;
+	AT.Multiply(ATb,b);
+	ATA.ConjugateGradient(result,ATb);
+}
+
+#ifdef _QT
+
+bool Matrix::writeMatrix(QFile &file) const
+{
+	file.write((char *)&nRow,sizeof(int));
+	file.write((char *)&nCol,sizeof(int));
+	if(file.write((char *)pData,sizeof(double)*nRow*nCol)!=sizeof(double)*nRow*nCol)
+		return false;
+	return true;
+}
+
+bool Matrix::readMatrix(QFile &file)
+{
+	releaseData();
+	file.read((char *)&nRow,sizeof(int));
+	file.read((char *)&nCol,sizeof(int));
+	if(nRow*nCol>0)
+	{
+		allocate(nRow,nCol);
+		if(file.read((char *)pData,sizeof(double)*nRow*nCol)!=sizeof(double)*nRow*nCol)
+			return false;
+	}
+	return true;
+}
+#endif
+
+#ifdef _MATLAB
+
+void Matrix::readMatrix(const mxArray* prhs)
+{
+	if(pData!=NULL)
+		delete pData;
+	int nElements = mxGetNumberOfDimensions(prhs);
+	if(nElements>2)
+		mexErrMsgTxt("A matrix is expected to be loaded!");
+	const mwSize* dims = mxGetDimensions(prhs);
+	allocate(dims[0],dims[1]);
+	double* data = (double*)mxGetData(prhs);
+	for(int i =0; i<nRow; i++)
+		for(int j =0; j<nCol; j++)
+			pData[i*nCol+j] = data[j*nRow+i];
+}
+
+void Matrix::writeMatrix(mxArray*& plhs) const
+{
+	mwSize dims[2];
+	dims[0]=nRow;dims[1]=nCol;
+	plhs=mxCreateNumericArray(2, dims,mxDOUBLE_CLASS, mxREAL);
+	double* data = (double *)mxGetData(plhs);
+	for(int i =0; i<nRow; i++)
+		for(int j =0; j<nCol; j++)
+			data[j*nRow+i] = pData[i*nCol+j];
+}
+
+#endif

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/Matrix.h

@@ -0,0 +1,92 @@
+#ifndef _Matrix_h
+#define _Matrix_h
+
+#include "stdio.h"
+#include "Vector.h"
+#include "project.h"
+#ifdef _QT
+	#include <QFile>
+#endif
+
+class Matrix
+{
+private:
+	int nRow,nCol;
+	double* pData;
+	static bool IsDispInfo;
+public:
+	Matrix(void);
+	Matrix(int _nrow,int _ncol,double* data=NULL);
+	Matrix(const Matrix& matrix);
+	~Matrix(void);
+	void releaseData();
+	void copyData(const Matrix& matrix);
+	void allocate(const Matrix& matrix);
+	void allocate(int _nrow,int _ncol);
+	void reset();
+	bool dimMatch(const Matrix& matrix) const;
+	bool dimcheck(const Matrix& matrix) const;
+	void loadData(int _nrow,int _ncol,double* data);
+	static void enableDispInfo(bool dispInfo=false){IsDispInfo=dispInfo;};
+	// display the matrix
+	void printMatrix();
+	void identity(int ndim);
+
+	// function to access the member variables
+	inline int nrow() const{return nRow;};
+	inline int ncol() const{return nCol;};
+	inline double* data() {return pData;};
+	inline const double* data() const {return (const double*)pData;};
+	inline double operator [](int index) const{return pData[index];};
+	inline double& operator[](int index) {return pData[index];};
+	inline double data(int row,int col)const {return pData[row*nCol+col];};
+	inline double& data(int row,int col) {return pData[row*nCol+col];};
+	bool matchDimension(int _nrow,int _ncol) const {if(nRow==_nrow && nCol==_ncol) return true; else return false;};
+	bool matchDimension(const Matrix& matrix) const {return matchDimension(matrix.nrow(),matrix.ncol());};
+
+	// functions to check dimensions
+	bool checkDimRight(const Vector& vector) const;
+	bool checkDimRight(const Matrix& matrix) const;
+	bool checkDimLeft(const Vector& vector) const;
+	bool checkDimLeft(const Matrix& matrix) const;
+
+	// functions for matrix computation
+	void Multiply(Vector& result,const Vector& vect) const;
+	void Multiply(Matrix& result,const Matrix& matrix) const;
+
+	void transpose(Matrix& result) const;
+	void fromVector(const Vector& vect);
+	double norm2() const;
+
+	// operators
+	Matrix& operator=(const Matrix& matrix);
+	
+	Matrix& operator+=(double val);
+	Matrix& operator-=(double val);
+	Matrix& operator*=(double val);
+	Matrix& operator/=(double val);
+	
+	Matrix& operator+=(const Matrix& matrix);
+	Matrix& operator-=(const Matrix& matrix);
+	Matrix& operator*=(const Matrix& matrix);
+	Matrix& operator/=(const Matrix& matrix);
+
+	friend Vector operator*(const Matrix& matrix,const Vector& vect);
+	friend Matrix operator*(const Matrix& matrix1,const Matrix& matrix2);
+
+	
+	// solve linear systems
+	void SolveLinearSystem(Vector& result,const Vector& b) const;
+	void ConjugateGradient(Vector& result,const Vector& b) const;
+
+#ifdef _QT
+	bool writeMatrix(QFile& file) const;
+	bool readMatrix(QFile& file);
+#endif
+#ifdef _MATLAB
+	void readMatrix(const mxArray* prhs);
+	void writeMatrix(mxArray*& prhs) const;
+#endif
+};
+
+#endif

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/Vector.cpp

@@ -0,0 +1,285 @@
+#include "Vector.h"
+#include "memory.h"
+#include <iostream>
+
+using namespace std;
+
+Vector::Vector(void)
+{
+	nDim=0;
+	pData=NULL;
+}
+
+Vector::Vector(int ndim, double *data)
+{
+	nDim=ndim;
+	pData=new double[nDim];
+	if(data!=NULL)
+		memcpy(pData,data,sizeof(double)*nDim);
+	else
+		memset(pData,0,sizeof(double)*nDim);
+}
+
+Vector::Vector(const Vector& vect)
+{
+	nDim=0;
+	pData=NULL;
+	copyData(vect);
+}
+
+Vector::~Vector(void)
+{
+	releaseData();
+}
+
+void Vector::releaseData()
+{
+	if(pData!=NULL)
+		delete pData;
+	pData=NULL;
+	nDim=0;
+}
+
+void Vector::allocate(int ndim)
+{
+	releaseData();
+	nDim=ndim;
+	if(nDim>0)
+		pData=new double[nDim];
+}
+
+void Vector::copyData(const Vector &vect)
+{
+	if(nDim!=vect.nDim)
+	{
+		releaseData();
+		nDim=vect.nDim;
+		pData=new double[nDim];
+	}
+	memcpy(pData,vect.pData,sizeof(double)*nDim);
+}
+
+void Vector::dimcheck(const Vector &vect) const
+{
+	if(nDim!=vect.nDim)
+		cout<<"The dimensions of the vectors don't match!"<<endl;
+}
+
+void Vector::reset()
+{
+	if(pData!=NULL)
+		memset(pData,0,sizeof(double)*nDim);
+}
+
+double Vector::sum() const
+{
+	double total = 0;
+	for(int i=0;i<nDim;i++)
+		total += pData[i];
+	return total;
+}
+
+double Vector::norm2() const
+{
+	double temp=0;
+	for(int i=0;i<nDim;i++)
+		temp+=pData[i]*pData[i];
+	return temp;
+}
+
+void Vector::printVector()
+{
+	for(int i=0;i<nDim;i++)
+		printf("%.6f ",pData[i]);
+	printf("\n");
+}
+
+//----------------------------------------------------------------------------------
+// operators
+//----------------------------------------------------------------------------------
+Vector& Vector::operator =(const Vector &vect)
+{
+	copyData(vect);
+	return *this;
+}
+
+Vector& Vector::operator +=(const Vector &vect)
+{
+	dimcheck(vect);
+	for(int i=0;i<nDim;i++)
+		pData[i]+=vect.data()[i];
+	return *this;
+}
+
+Vector& Vector::operator *=(const Vector &vect)
+{
+	dimcheck(vect);
+	for(int i=0;i<nDim;i++)
+		pData[i]*=vect.data()[i];
+	return *this;
+}
+
+Vector& Vector::operator -=(const Vector &vect)
+{
+	dimcheck(vect);
+	for(int i=0;i<nDim;i++)
+		pData[i]-=vect.data()[i];
+	return *this;
+}
+
+Vector& Vector::operator /=(const Vector &vect)
+{
+	dimcheck(vect);
+	for(int i=0;i<nDim;i++)
+		pData[i]/=vect.data()[i];
+	return *this;
+}
+
+Vector& Vector::operator +=(double val)
+{
+	for(int i=0;i<nDim;i++)
+		pData[i]+=val;
+	return *this;
+}
+
+Vector& Vector::operator *=(double val)
+{
+	for(int i=0;i<nDim;i++)
+		pData[i]*=val;
+	return *this;
+}
+
+Vector& Vector::operator -=(double val)
+{
+	for(int i=0;i<nDim;i++)
+		pData[i]-=val;
+	return *this;
+}
+
+Vector& Vector::operator /=(double val)
+{
+	for(int i=0;i<nDim;i++)
+		pData[i]/=val;
+	return *this;
+}
+
+const Vector operator+(const Vector& vect1,const Vector& vect2)
+{
+	vect1.dimcheck(vect2);
+	Vector result(vect1);
+	result+=vect2;
+	return result;
+}
+
+const Vector operator-(const Vector& vect1,const Vector& vect2)
+{
+	vect1.dimcheck(vect2);
+	Vector result(vect1);
+	result-=vect2;
+	return result;
+}
+
+const Vector operator*(const Vector& vect1,const Vector& vect2)
+{
+	vect1.dimcheck(vect2);
+	Vector result(vect1);
+	result*=vect2;
+	return result;
+}
+
+const Vector operator/(const Vector& vect1,const Vector& vect2)
+{
+	vect1.dimcheck(vect2);
+	Vector result(vect1);
+	result/=vect2;
+	return result;
+}
+
+const Vector operator+(const Vector& vect,double val)
+{
+	Vector result(vect);
+	result+=val;
+	return result;
+}
+
+const Vector operator-(const Vector& vect,double val)
+{
+	Vector result(vect);
+	result-=val;
+	return result;
+}
+
+const Vector operator*(const Vector& vect,double val)
+{
+	Vector result(vect);
+	result*=val;
+	return result;
+}
+
+const Vector operator/(const Vector& vect,double val)
+{
+	Vector result(vect);
+	result/=val;
+	return result;
+}
+
+double innerproduct(const Vector& vect1,const Vector& vect2)
+{
+	vect1.dimcheck(vect2);
+	double result=0;
+	for(int i=0;i<vect1.nDim;i++)
+		result+=vect1.pData[i]*vect2.pData[i];
+	return result;
+}
+
+#ifdef _QT
+
+bool Vector::writeVector(QFile& file) const
+{
+	file.write((char *)&nDim,sizeof(int));
+	if(file.write((char *)pData,sizeof(double)*nDim)!=sizeof(double)*nDim)
+		return false;
+	return true;
+}
+
+bool Vector::readVector(QFile &file)
+{
+	releaseData();
+	file.read((char *)&nDim,sizeof(int));
+	if(nDim<0)
+		return false;
+	if(nDim>0)
+	{
+		allocate(nDim);
+		if(file.read((char *)pData,sizeof(double)*nDim)!=sizeof(double)*nDim)
+			return false;
+	}
+	return true;
+}
+
+#endif
+
+#ifdef _MATLAB
+
+void Vector::readVector(const mxArray* prhs)
+{
+	if(pData!=NULL)
+		delete pData;
+	int nElements = mxGetNumberOfDimensions(prhs);
+	if(nElements>2)
+		mexErrMsgTxt("A vector is expected to be loaded!");
+	const mwSize* dims = mxGetDimensions(prhs);
+	nDim = dims[0]*dims[1];
+	pData = new double[nDim];
+	memcpy(pData,(double*)mxGetData(prhs),sizeof(double)*nDim);
+}
+
+void Vector::writeVector(mxArray*& plhs) const
+{
+	mwSize dims[2];
+	dims[0]=nDim;dims[1]=1;
+	plhs=mxCreateNumericArray(2, dims,mxDOUBLE_CLASS, mxREAL);
+    memcpy((double *)mxGetData(plhs),pData,sizeof(double)*nDim);
+}
+
+#endif

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/Vector.h

@@ -0,0 +1,73 @@
+#ifndef _Vector_h
+#define _Vector_h
+
+#include "stdio.h"
+#include "project.h"
+#ifdef _QT
+	#include <QFile>
+#endif
+
+class Vector
+{
+private:
+	int nDim;
+	double* pData;
+public:
+	Vector(void);
+	Vector(int ndim,double *data=NULL);
+	Vector(const Vector& vect);
+	~Vector(void);
+	void releaseData();
+	void allocate(int ndim);
+	void allocate(const Vector& vect){allocate(vect.nDim);};
+	void copyData(const Vector& vect);
+	void dimcheck(const Vector& vect) const;
+	void reset();
+	double norm2() const;
+	double sum() const;
+	void printVector();
+
+	// access the members
+	const double* data() const{return (const double*)pData;};
+	double* data() {return pData;};
+	int dim() const {return nDim;};
+	inline bool matchDimension(int _ndim) const {if(nDim==_ndim) return true;else return false;};
+	inline bool matchDimension(const Vector& vect) const {return matchDimension(vect.nDim);};
+
+	// operators
+	inline double operator[](int index) const {return pData[index];};
+	inline double& operator[](int index){return *(pData+index);};
+	Vector& operator=(const Vector& vect);
+	
+	Vector& operator+=(const Vector& vect);
+	Vector& operator*=(const Vector& vect);
+	Vector& operator-=(const Vector& vect);
+	Vector& operator/=(const Vector& vect);
+
+	Vector& operator+=(double val);
+	Vector& operator*=(double val);
+	Vector& operator-=(double val);
+	Vector& operator/=(double val);
+	
+	friend const Vector operator+(const Vector& vect1,const Vector& vect2);
+	friend const Vector operator*(const Vector& vect1,const Vector& vect2);
+	friend const Vector operator-(const Vector& vect1,const Vector& vect2);
+	friend const Vector operator/(const Vector& vect1,const Vector& vect2);
+
+	friend const Vector operator+(const Vector& vect1,double val);
+	friend const Vector operator*(const Vector& vect1,double val);
+	friend const Vector operator-(const Vector& vect1,double val);
+	friend const Vector operator/(const Vector& vect1,double val);
+
+	friend double innerproduct(const Vector& vect1,const Vector& vect2);
+#ifdef _QT
+	bool writeVector(QFile& file) const;
+	bool readVector(QFile& file);
+#endif
+#ifdef _MATLAB
+	void readVector(const mxArray* prhs);
+	void writeVector(mxArray*& prhs) const;
+#endif
+};
+
+#endif

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/dir.cpp

@@ -0,0 +1,121 @@
+#include "dir.h"
+
+//------------------------------------------------------------------------------------
+// function to load all sub folders for a given directory
+//------------------------------------------------------------------------------------
+vector<string> dir::getSubfolders(LPCSTR path)
+{
+	// make sure that the path has an ok format
+	string Path(path);
+	if(Path[Path.size()-1]!='*')
+	{
+		if(Path[Path.size()-1]!='\\')
+			Path.push_back('\\');
+		Path.push_back('*');
+	}
+	vector<string> subfolders;
+   WIN32_FIND_DATA FindFileData;
+   HANDLE hFind;
+	
+   hFind = FindFirstFile(Path.data(), &FindFileData);
+   if (hFind == INVALID_HANDLE_VALUE) 
+   {
+      printf ("FindFirstFile failed (%d)\n", GetLastError());
+      return subfolders;
+   } 
+   bool IsFound;
+   do{
+	   if((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)== FILE_ATTRIBUTE_DIRECTORY &&
+		   (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) != FILE_ATTRIBUTE_SYSTEM)
+	   {
+		   if(strcmp(FindFileData.cFileName,".") != 0 && strcmp(FindFileData.cFileName,"..") != 0)
+		   {
+			   //wcout<<FindFileData.dwFileAttributes << "\t" << FindFileData.cFileName <<endl;
+			   subfolders.push_back(string(FindFileData.cFileName));
+		   }
+	   }
+	   
+	   IsFound = FindNextFile(hFind,&FindFileData);
+   }while(IsFound);
+   FindClose(hFind);
+   return subfolders;
+}
+
+//------------------------------------------------------------------------------------
+// function to load all sub folders for a given directory
+//------------------------------------------------------------------------------------
+vector<string> dir::readFiles(LPCSTR path)
+{
+	vector<string> subfolders;
+   WIN32_FIND_DATA FindFileData;
+   HANDLE hFind;
+	
+   hFind = FindFirstFile(path, &FindFileData);
+   if (hFind == INVALID_HANDLE_VALUE) 
+   {
+      //printf ("FindFirstFile failed (%d)\n", GetLastError());
+      return subfolders;
+   } 
+   bool IsFound;
+   do{
+	   subfolders.push_back(string(FindFileData.cFileName));
+	   //wcout<<FindFileData.dwFileAttributes << "\t" << FindFileData.cFileName <<endl;
+	   IsFound = FindNextFile(hFind,&FindFileData);
+   }while(IsFound);
+   FindClose(hFind);
+   return subfolders;
+}
+
+//------------------------------------------------------------------------------------
+// function to load all images in a given folder
+//------------------------------------------------------------------------------------
+vector<string> dir::readImages(LPCSTR path)
+{
+	string Path(path);
+	if(Path[Path.size()-1]!='\\')
+		Path.push_back('\\');
+
+	vector<string> filelist;
+	LPCSTR imgformats[4]={"*.jpg","*.jpeg","*.bmp","*.png"};//,L"*.gif"};
+	for(int  i=0;i<4;i++)
+	{
+		vector<string> templist;
+		string search(Path);
+		search+= imgformats[i];
+		//wcout<<search.data() <<endl;
+		templist = readFiles(search.data());
+		
+		for(int j = 0;j<templist.size(); j++)
+			filelist.push_back(templist[j]);
+	}
+	return filelist;
+}
+
+//------------------------------------------------------------------------------------
+// function to convert wstring to string
+//------------------------------------------------------------------------------------
+string dir::wstring2string(const wstring& wstr)
+{
+	string s(wstr.begin(),wstr.end());
+	s.assign(wstr.begin(),wstr.end());
+	return s;
+}
+
+wstring dir::string2wstring(const string& str)
+{
+	wstring ws(str.begin(),str.end());
+	ws.assign(str.begin(),str.end());
+	return ws;
+}
+
+//------------------------------------------------------------------------------------
+// function to change file extension
+//------------------------------------------------------------------------------------
+string dir::changeFileExt(const string& path,const string& ext)
+{
+	string newpath;
+	int dot = path.find_last_of('.');
+	newpath = path.substr(0,dot+1);
+	newpath+=ext;
+	return newpath;
+}

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/dir.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "stdlib.h"
+#include <windows.h>
+#include <tchar.h>
+#include <stdio.h>
+#include <iostream>
+#include <vector>
+#include <string>
+
+
+using namespace std;
+
+namespace dir
+{
+	vector<string> getSubfolders( LPCSTR path);
+	vector<string> readFiles( LPCSTR path);
+
+	vector<string> readImages(LPCSTR path);
+
+	wstring string2wstring(const string& str);
+	string    wstring2string(const wstring& wstr);
+
+	string changeFileExt(const string& path,const string& ext);
+};

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/mexDenseSIFT.cpp

@@ -0,0 +1,47 @@
+#include "mex.h"
+#include "Image.h"
+#include "ImageFeature.h"
+#include "Vector.h"
+#include <vector>
+
+void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
+{
+	DImage im;
+	im.LoadMatlabImage(prhs[0]);
+
+	bool IsMultiScale = false;
+	vector<int> cellSizeVect;
+	int cellSize = 3;
+	int stepSize = 1;
+	bool IsBoundaryIncluded = true;
+
+	Vector para;
+	if(nrhs>1) // if cell size is inputed
+	{
+		para.readVector(prhs[1]);
+		if(para.dim()>1)
+		{
+			IsMultiScale = true;
+			for(int i = 0;i<para.dim();i++)
+				cellSizeVect.push_back(para[i]);
+		}
+		else
+			cellSize = para[0];
+	}
+	if(nrhs>2)
+	{
+		para.readVector(prhs[2]);
+		stepSize = para[0];
+	}
+	if(nrhs>3)
+	{
+		para.readVector(prhs[3]);
+		IsBoundaryIncluded = para[0]>0;
+	}
+	UCImage imsift;
+	if(IsMultiScale)
+		ImageFeature::imSIFT(im,imsift,cellSizeVect,stepSize,IsBoundaryIncluded);
+	else
+		ImageFeature::imSIFT(im,imsift,cellSize,stepSize,IsBoundaryIncluded);
+	imsift.OutputToMatlab(plhs[0]);
+}

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/mexDenseSIFT.m

@@ -0,0 +1,19 @@
+% The wrapper of mex function mexDenseSIFT.m. See demo_mexDenseSIFT.m for an example of usage.
+%
+% sift = mexDenseSIFT(im,cellSize,stepSize,IsBoundary);
+%
+% Input arguments
+%   im  --          an RGB or grayscale image (either uint8 or double) 
+%   cellSize -- (default: 3) a vector of cell size. If a scale is input, then the SIFT descriptor of one cell size is
+%                        computed; if a vector is input, then multi-scale SIFT is computed and concatenated. 
+%   stepSize -- (default: 1) a scale of step size in sampling image grid. If an integer larger than 1 is input, then
+%                       sparse sampling of image grid is performed
+%  IsBoundary-- (default: true) a boolean variable indicating whether boundary is included.
+%
+% Output
+%   sift --         an image (with multiple channels, typicallly 128) of datatype UINT8 despite the type of the input.
+%                       The maximum element wise value of sift is 255. This datatype is consistent with the byte-based
+%                       SIFT flow algorithm
+%
+%  Ce Liu
+%  June 29, 2010

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/project.h

@@ -0,0 +1,47 @@
+#pragma once
+#include "stdio.h"
+
+// if the files are compiled in linux or mac os then uncomment the following line, otherwise comment it if you compile using visual studio in windows
+ #define _LINUX_MAC
+#define _OPENCV
+
+template <class T>
+void _Release1DBuffer(T* pBuffer)
+{
+	if(pBuffer!=NULL)
+		delete []pBuffer;
+	pBuffer=NULL;
+}
+
+template <class T>
+void _Rlease2DBuffer(T** pBuffer,size_t nElements)
+{
+	for(size_t i=0;i<nElements;i++)
+		delete [](pBuffer[i]);
+	delete []pBuffer;
+	pBuffer=NULL;
+}
+
+
+#define _MATLAB
+
+#ifdef _MATLAB
+#include "mex.h"
+#endif
+
+
+#ifdef _LINUX_MAC
+
+template <class T1,class T2>
+T1 __min(T1 a, T2 b)
+{
+  return (a>b)?b:a;
+}
+
+template <class T1,class T2>
+T1 __max(T1 a, T2 b)
+{
+  return (a<b)?b:a;
+}
+
+#endif

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/readme.txt

@@ -0,0 +1,12 @@
+The *.cpp and *.h files in this folder are used to mex a matlab dll file for computing dense SIFT features. Use the following command to compile in Matlab (tested on version 7.6 or later)
+
+mex mexDenseSIFT.cpp Matrix.cpp Vector.cpp
+
+It has been tested in Windows 7 x64, Linux x64 and Mac OS 10.6. Precompiled versions of Windows 7 x64 and Mac OS 10.6 are included in the folder.
+
+
+------------------------- Important -------------------------
+
+You must change one line in order to compile correctly. On line 5 of project.h, you should comment this line if you are compiling using visual studio in windows, or uncomment if you are in linux or mac os.
+
+-------------------------------------------------------------

UVDoc_official/eval/eval_code/SIFTflow/mexDenseSIFT/showColorSIFT.m

@@ -0,0 +1,23 @@
+function SIFTcolor=showColorSIFT(SIFT)
+%
+% It reduces the dimensionality of SIFT to 3 dimensions and outputs a color
+% coded image
+%
+% It will map the first PCA dimension to luminance (R+G+B), then it will
+% map the second to R-G and the third one to (R+G)/2-B
+
+load ('pcSIFT', 'pcSIFT')
+
+[nrows ncols nfeatures] = size(SIFT);
+SIFTpca = pcSIFT(:,1:3)'*double(reshape(SIFT, [nrows*ncols nfeatures]))';
+
+A = inv([1 1 1; 1 -1 0; .5 .5 -1]);
+%A = eye(3,3);
+
+SIFTcolor = A * SIFTpca(1:3,:);
+SIFTcolor = reshape(SIFTcolor', [nrows ncols 3]);
+SIFTcolor = SIFTcolor - min(SIFTcolor(:));
+SIFTcolor = SIFTcolor / max(SIFTcolor(:));
+%SIFTcolor = uint8(255*SIFTcolor / max(SIFTcolor(:)));
+%imshow(SIFTcolor)
+

UVDoc_official/eval/eval_code/SIFTflow/mexDiscreteFlow/BPFlow.cpp

@@ -0,0 +1,1084 @@
+#include "stdio.h"
+#include "project.h"
+#include "BPFlow.h"
+#include "memory.h"
+#include "math.h"
+#include "stdlib.h"
+#include "Stochastic.h"
+
+BPFlow::BPFlow(void)
+{
+#ifdef _MATLAB
+	IsDisplay=false;
+#else
+	IsDisplay=true;
+#endif
+   IsDataTermTruncated=false;
+   IsTRW=false;
+	CTRW=(double)1/2;
+   //CTRW=0.55;
+	Width=Height=Area=0;
+	pIm1=pIm2=NULL;
+	for(int i=0;i<2;i++)
+	{
+		pOffset[i]=NULL;
+		pWinSize[i]=NULL;
+	}
+	pDataTerm=NULL;
+	ptrDataTerm=NULL;
+	for(int i=0;i<2;i++)
+	{
+		pRangeTerm[i]=pSpatialMessage[i]=pDualMessage[i]=pBelief[i]=NULL;
+		ptrRangeTerm[i]=ptrSpatialMessage[i]=ptrDualMessage[i]=ptrBelief[i]=NULL;
+	}
+	pX=NULL;
+	nNeighbors=4;
+}
+
+BPFlow::~BPFlow(void)
+{
+	ReleaseBuffer();
+}
+
+void BPFlow::ReleaseBuffer()
+{
+	_Release1DBuffer(pIm1);
+	_Release1DBuffer(pIm2);
+
+	for(int i=0;i<2;i++)
+	{
+		_Release1DBuffer(pOffset[i]); // release the buffer of the offset
+		_Release1DBuffer(pWinSize[i]); // release the buffer of the size
+	}
+
+	_Release1DBuffer(pDataTerm);
+	_Release1DBuffer(ptrDataTerm);
+	for(int i=0;i<2;i++)
+	{
+		_Release1DBuffer(pRangeTerm[i]);
+		_Release1DBuffer(ptrRangeTerm[i]);
+		_Release1DBuffer(pSpatialMessage[i]);
+		_Release1DBuffer(ptrSpatialMessage[i]);
+		_Release1DBuffer(pDualMessage[i]);
+		_Release1DBuffer(ptrDualMessage[i]);
+		_Release1DBuffer(pBelief[i]);
+		_Release1DBuffer(ptrBelief[i]);
+	}
+	_Release1DBuffer(pX);
+}
+
+//---------------------------------------------------------------------------------
+// set the parameter of the model
+// the regularization is a truncated L1 norm: __min(s|v(x,y)-v(x+1,y)|,d)
+// sigma is used to penalize large displacement
+//---------------------------------------------------------------------------------
+void BPFlow::setPara(double _s,double _d)
+{
+	s=_s;
+	d=_d;
+	//printf("s: %f, d: %f\n",s,d);
+	if(Width>0)
+	{
+		Im_s.allocate(Width,Height,2);
+		Im_d.allocate(Width,Height,2);
+		Im_s.setValue(s);
+		Im_d.setValue(d);
+	}
+	else
+		printf("The image dimension has not been specified! Call LoadImages() first\n");
+}	
+
+//----------------------------------------------------------------------
+// function to load images
+//----------------------------------------------------------------------
+void BPFlow::LoadImages(int _width, int _height, int _nchannels, const T_input *pImage1, const T_input *pImage2)
+{
+	Width=_width;
+	Height=_height;
+	Area=Width*Height;
+	nChannels=_nchannels;
+
+	_Release1DBuffer(pIm1);
+	_Release1DBuffer(pIm2);
+	pIm1=new T_input[Width*Height*nChannels];
+	pIm2=new T_input[Width*Height*nChannels];
+
+	memcpy(pIm1,pImage1,sizeof(T_input)*Width*Height*nChannels);
+	memcpy(pIm2,pImage2,sizeof(T_input)*Width*Height*nChannels);
+    
+    Width2=Width;
+    Height2=Height;
+}
+
+
+void BPFlow::LoadImages(int _width, int _height, int _nchannels, const T_input *pImage1, 
+                                                    int _width2,int _height2, const T_input *pImage2)
+{
+	Width=_width;
+	Height=_height;
+	Area=Width*Height;
+	nChannels=_nchannels;
+    Width2=_width2;
+    Height2=_height2;
+
+	_Release1DBuffer(pIm1);
+	_Release1DBuffer(pIm2);
+	pIm1=new T_input[Width*Height*nChannels];
+	pIm2=new T_input[Width2*Height2*nChannels];
+
+	memcpy(pIm1,pImage1,sizeof(T_input)*Width*Height*nChannels);
+	memcpy(pIm2,pImage2,sizeof(T_input)*Width2*Height2*nChannels);
+}
+
+//------------------------------------------------------------------------------------------------
+// function to set the homogeneous MRF parameters
+// There is no offset, and the window size is identical for each pixel (winSize)
+//------------------------------------------------------------------------------------------------
+void BPFlow::setHomogeneousMRF(int winSize)
+{
+	for(int i=0;i<2;i++)
+	{
+		_Release1DBuffer(pOffset[i]); // release the buffer of the offset
+		_Release1DBuffer(pWinSize[i]); // release the buffer of the size
+		pOffset[i]=new T_state[Area];
+		memset(pOffset[i],0,sizeof(T_state)*Area);
+
+		pWinSize[i]=new T_state[Area];
+		for(size_t j=0;j<Area;j++)
+			pWinSize[i][j]=winSize;//+CStochastic::UniformSampling(3)-1;
+	}
+	// add some disturbance
+	for(int i=0;i<2;i++)
+		for(int j=0;j<Area;j++)
+			pOffset[i][j]=CStochastic::UniformSampling(5)-2;
+}
+
+
+//------------------------------------------------------------------------------------------------
+// function to verify whether a poit is inside image boundary or not
+//------------------------------------------------------------------------------------------------
+template <class T>
+bool BPFlow::InsideImage(T x,T y)
+{
+	if(x>=0 && x<Width2 && y>=0 && y<Height2)
+		return true;
+	else
+		return false;
+}
+
+//------------------------------------------------------------------------------------------------
+// function to compute range term
+//------------------------------------------------------------------------------------------------
+void BPFlow::ComputeRangeTerm(double _gamma)
+{
+	gamma=_gamma;
+	for(int i=0;i<2;i++)
+	{
+		_Release1DBuffer(pRangeTerm[i]);
+		_Release1DBuffer(ptrRangeTerm[i]);
+		AllocateBuffer(pRangeTerm[i],1,ptrRangeTerm[i],pWinSize[i]);
+	}
+	for(ptrdiff_t offset=0;offset<Area;offset++)
+	{
+		for(ptrdiff_t plane=0;plane<2;plane++)
+		{
+			int winsize=pWinSize[plane][offset];
+			for(ptrdiff_t j=-winsize;j<=winsize;j++)
+				pRangeTerm[plane][offset].data()[j+winsize]=gamma*fabs((double)j+pOffset[plane][offset]);
+		}
+	}
+}
+
+//------------------------------------------------------------------------------------------------
+// function to compute data term
+//------------------------------------------------------------------------------------------------
+void BPFlow::ComputeDataTerm()
+{
+	// allocate the buffer for data term
+	nTotalMatches=AllocateBuffer<PixelBuffer2D<T_message>,T_message>(pDataTerm,ptrDataTerm,pWinSize[0],pWinSize[1]);
+
+	T_message HistMin,HistMax;
+	double HistInterval;
+	double* pHistogramBuffer;
+	int nBins=20000;
+	int total=0; // total is the total number of plausible matches, used to normalize the histogram
+	pHistogramBuffer=new double[nBins];
+	memset(pHistogramBuffer,0,sizeof(double)*nBins);
+	HistMin= 32767;
+	HistMax=0;
+	//--------------------------------------------------------------------------------------------------
+	// step 1. the first sweep to compute the data term for the visible matches
+	//--------------------------------------------------------------------------------------------------
+	for(ptrdiff_t i=0;i<Height;i++)			// index over y
+		for(ptrdiff_t j=0;j<Width;j++)		// index over x
+		{
+			size_t index=i*Width+j;
+			int XWinLength=pWinSize[0][index]*2+1;
+			// loop over a local window
+			for(ptrdiff_t k=-pWinSize[1][index];k<=pWinSize[1][index];k++)  // index over y
+				for(ptrdiff_t l=-pWinSize[0][index];l<=pWinSize[0][index];l++)  // index over x
+				{
+					ptrdiff_t x=j+pOffset[0][index]+l;
+					ptrdiff_t y=i+pOffset[1][index]+k;
+
+					// if the point is outside the image boundary then continue
+					if(!InsideImage(x,y))
+						continue;
+					ptrdiff_t index2=y*Width2+x;
+					T_message foo=0;
+					for(int n=0;n<nChannels;n++)
+						foo+=abs(pIm1[index*nChannels+n]-pIm2[index2*nChannels+n]); // L1 norm
+//#ifdef INTMESSAGE
+//						foo+=abs(pIm1[index*nChannels+n]-pIm2[index2*nChannels+n]); // L1 norm
+//#else
+//						foo+=fabs(pIm1[index*nChannels+n]-pIm2[index2*nChannels+n]); // L1 norm
+//#endif
+						
+					
+					pDataTerm[index][(k+pWinSize[1][index])*XWinLength+l+pWinSize[0][index]]=foo;
+					HistMin=__min(HistMin,foo);
+					HistMax=__max(HistMax,foo);
+					total++;
+				}
+		}
+	// compute the histogram info
+	HistInterval=(double)(HistMax-HistMin)/nBins;
+	//HistInterval/=21;
+
+	//--------------------------------------------------------------------------------------------------
+	// step 2. get the histogram of the matching
+	//--------------------------------------------------------------------------------------------------
+	for(ptrdiff_t i=0;i<Height;i++)			// index over y
+		for(ptrdiff_t j=0;j<Width;j++)		// index over x
+		{
+			size_t index=i*Width+j;
+			int XWinLength=pWinSize[0][index]*2+1;
+			// loop over a local window
+			for(ptrdiff_t k=-pWinSize[1][index];k<=pWinSize[1][index];k++)  // index over y
+				for(ptrdiff_t l=-pWinSize[0][index];l<=pWinSize[0][index];l++)  // index over x
+				{
+					ptrdiff_t x=j+pOffset[0][index]+l;
+					ptrdiff_t y=i+pOffset[1][index]+k;
+
+					// if the point is outside the image boundary then continue
+					if(!InsideImage(x,y))
+						continue;
+					int foo=__min(pDataTerm[index][(k+pWinSize[1][index])*XWinLength+l+pWinSize[0][index]]/HistInterval,nBins-1);
+					pHistogramBuffer[foo]++;
+				}
+		}
+	for(size_t i=0;i<nBins;i++) // normalize the histogram
+		pHistogramBuffer[i]/=total;
+
+	T_message DefaultMatchingScore;
+	double Prob=0;
+	for(size_t i=0;i<nBins;i++)
+	{
+		Prob+=pHistogramBuffer[i];
+		if(Prob>=0.5)//(double)Area/nTotalMatches) // find the matching score
+		{
+			DefaultMatchingScore=__max(i,1)*HistInterval+HistMin; 
+			break;
+		}
+	}
+	//DefaultMatchingScore=__min(100*DefaultMatchingScore,HistMax/10);
+	if(IsDisplay)
+#ifdef INTMESSAGE
+		printf("Min: %d, Default: %d, Max: %d\n",HistMin,DefaultMatchingScore,HistMax);
+#else
+		printf("Min: %f, Default: %f, Max: %f\n",HistMin,DefaultMatchingScore,HistMax);
+#endif
+
+	//DefaultMatchingScore=0.1;
+	//--------------------------------------------------------------------------------------------------
+	// step 3. assigning the default matching score to the outside matches
+	//--------------------------------------------------------------------------------------------------
+	for(ptrdiff_t i=0;i<Height;i++)			// index over y
+		for(ptrdiff_t j=0;j<Width;j++)		// index over x
+		{
+			size_t index=i*Width+j;
+			int XWinLength=pWinSize[0][index]*2+1;
+			// loop over a local window
+			for(ptrdiff_t k=-pWinSize[1][index];k<=pWinSize[1][index];k++)  // index over y
+				for(ptrdiff_t l=-pWinSize[0][index];l<=pWinSize[0][index];l++)  // index over x
+				{
+					ptrdiff_t x=j+pOffset[0][index]+l;
+					ptrdiff_t y=i+pOffset[1][index]+k;
+
+                    int _ptr=(k+pWinSize[1][index])*XWinLength+l+pWinSize[0][index];
+					// if the point is outside the image boundary then continue
+					if(!InsideImage(x,y))
+						pDataTerm[index][_ptr]=DefaultMatchingScore;
+                     else if (IsDataTermTruncated) // put truncaitons to the data term
+                        pDataTerm[index][_ptr]=__min(pDataTerm[index][_ptr],DefaultMatchingScore);
+				}
+		}
+	delete pHistogramBuffer;
+}
+
+//------------------------------------------------------------------------------------------------
+//	function to allocate buffer for the messages
+//------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+size_t BPFlow::AllocateBuffer(T1*& pBuffer,size_t factor,T2*& ptrData,const int* pWinSize)
+{
+	pBuffer=new T1[Area*factor];
+	size_t totalElements=0;
+	for(ptrdiff_t i=0;i<Area;i++)
+	{
+		totalElements+=pWinSize[i]*2+1;
+		for(ptrdiff_t j=0;j<factor;j++)
+			pBuffer[i*factor+j].allocate(pWinSize[i]*2+1);
+	}
+	totalElements*=factor;
+	ptrData=new T2[totalElements];
+	memset(ptrData,0,sizeof(T2)*totalElements);
+
+	T2* ptrDynamic=ptrData;
+	size_t total=0;
+	for(ptrdiff_t i=0;i<Area*factor;i++)
+	{
+		pBuffer[i].data()=ptrDynamic;
+		ptrDynamic+=pBuffer[i].nElements();
+		total+=pBuffer[i].nElements();
+	}
+	return total;
+}
+
+template<class T1,class T2>
+size_t BPFlow::AllocateBuffer(T1*& pBuffer,T2*& ptrData,const int* pWinSize1,const int* pWinSize2)
+{
+	pBuffer=new T1[Area];
+	size_t totalElements=0;
+	for(ptrdiff_t i=0;i<Area;i++)
+	{
+		totalElements+=(pWinSize1[i]*2+1)*(pWinSize2[i]*2+1);
+		pBuffer[i].allocate(pWinSize1[i]*2+1,pWinSize2[i]*2+1);
+	}
+	ptrData=new T2[totalElements];
+	memset(ptrData,0,sizeof(T2)*totalElements);
+
+	T2* ptrDynamic=ptrData;
+	size_t total=0;
+	for(ptrdiff_t i=0;i<Area;i++)
+	{
+		pBuffer[i].data()=ptrDynamic;
+		ptrDynamic+=pBuffer[i].nElements();
+		total+=pBuffer[i].nElements();
+	}
+	return total;
+}
+
+void BPFlow::AllocateMessage()
+{
+	// delete the buffers for the messages
+	for(int i=0;i<2;i++)
+	{
+		_Release1DBuffer(pSpatialMessage[i]);
+		_Release1DBuffer(ptrSpatialMessage[i]);
+		_Release1DBuffer(pDualMessage[i]);
+		_Release1DBuffer(ptrDualMessage[i]);
+		_Release1DBuffer(pBelief[i]);
+		_Release1DBuffer(ptrBelief[i]);
+	}
+	// allocate the buffers for the messages
+	for(int i=0;i<2;i++)
+	{
+		nTotalSpatialElements[i]=AllocateBuffer(pSpatialMessage[i],nNeighbors,ptrSpatialMessage[i],pWinSize[i]);
+		nTotalDualElements[i]=AllocateBuffer(pDualMessage[i],1,ptrDualMessage[i],pWinSize[i]);
+		nTotalBelifElements[i]=AllocateBuffer(pBelief[i],1,ptrBelief[i],pWinSize[i]);
+	}
+}
+
+//------------------------------------------------------------------------------------------------
+// function for belief propagation
+//------------------------------------------------------------------------------------------------
+double BPFlow::MessagePassing(int nIterations,int nHierarchy,double* pEnergyList)
+{
+	AllocateMessage();
+	if(nHierarchy>0)
+	{
+		BPFlow bp;
+		generateCoarserLevel(bp);
+		bp.MessagePassing(20,nHierarchy-1);
+		bp.propagateFinerLevel(*this);
+	}
+	if(pX!=NULL)
+		_Release1DBuffer(pX);
+	pX=new int[Area*2];
+	double energy;
+	for(int count=0;count<nIterations;count++)
+	{
+		//Bipartite(count);
+		BP_S(count);
+		//TRW_S(count);
+		
+		//FindOptimalSolutionSequential();
+		ComputeBelief();
+		FindOptimalSolution();
+
+		energy=GetEnergy();
+		if(IsDisplay)
+			printf("No. %d energy: %f...\n",count,energy);
+		if(pEnergyList!=NULL)
+			pEnergyList[count]=energy;
+	}
+	return energy;
+}
+
+//------------------------------------------------------------------------------------------------
+// bipartite message update
+//------------------------------------------------------------------------------------------------
+void BPFlow::Bipartite(int count)
+{
+	// loop over vx and vy planes to update the message within each grid
+	for (int k=0; k<2; k++)
+		for (int i=0; i<Height; i++)
+			for (int j=0; j<Width; j++)
+			{
+				// the bipartite update
+				if (count%2==0 &&  (i+j)%2==k) // the even count
+					continue;
+				if (count%2==1 && (i+j)%2==1-k) // the odd count
+					continue;
+
+				//------------------------------------------------------------------------------------------------
+				// update the message from (j,i,k) to the neighbors on the same plane
+				//------------------------------------------------------------------------------------------------
+				// the encoding of the direction
+				//	0: left to right
+				//	1: right to left
+				//	2: top down
+				//	3: bottom up
+				for (int direction = 0; direction<4; direction++)
+					UpdateSpatialMessage(j,i,k,direction);
+
+				//-----------------------------------------------------------------------------------------------------
+				// update the message from (j,i,k) to the dual node (j,i,1-k)
+				//-----------------------------------------------------------------------------------------------------
+				if(count%4<2)
+					UpdateDualMessage(j,i,k);
+			}
+}
+
+void BPFlow::BP_S(int count)
+{
+	int k=count%2;
+	if (count%4<2) //forward update
+		for(int i=0;i<Height;i++)
+			for(int j=0;j<Width;j++)
+			{
+				UpdateSpatialMessage(j,i,k,0);
+				UpdateSpatialMessage(j,i,k,2);
+				if(count%8<4)
+					UpdateDualMessage(j,i,k);
+			}
+	else // backward upate
+		for(int i=Height-1;i>=0;i--)
+			for(int j=Width-1;j>=0;j--)
+			{
+				UpdateSpatialMessage(j,i,k,1);
+				UpdateSpatialMessage(j,i,k,3);
+				if(count%8<4)
+					UpdateDualMessage(j,i,k);
+			}
+}
+
+void BPFlow::TRW_S(int count)
+{
+	int k=count%2;
+	if (k==0) //forward update
+		for(int i=0;i<Height;i++)
+			for(int j=0;j<Width;j++)
+			{
+				for(int l=0;l<2;l++)
+				{
+					UpdateDualMessage(j,i,l);
+					UpdateSpatialMessage(j,i,l,0);
+					UpdateSpatialMessage(j,i,l,2);
+				}
+			}
+	else // backward upate
+		for(int i=Height-1;i>=0;i--)
+			for(int j=Width-1;j>=0;j--)
+			{
+				for(int l=0;l<2;l++)
+				{
+					UpdateDualMessage(j,i,l);
+					UpdateSpatialMessage(j,i,l,1);
+					UpdateSpatialMessage(j,i,l,3);
+				}					
+			}
+}
+
+
+//------------------------------------------------------------------------------------------------
+//  update the message from (x0,y0,plane) to the neighbors on the same plane
+//    the encoding of the direction
+//               2  |
+//                   v
+//    0 ------> <------- 1
+//                   ^
+//                3 |
+//------------------------------------------------------------------------------------------------
+void BPFlow::UpdateSpatialMessage(int x, int y, int plane, int direction)
+{
+	// eliminate impossible messages
+	if (direction==0 && x==Width-1)
+		return;
+	if (direction==1 && x==0)
+		return;
+	if (direction==2 && y==Height-1)
+		return;
+	if (direction==3 && y==0)
+		return;
+
+	int offset=y*Width+x;
+	int nStates=pWinSize[plane][offset]*2+1;
+
+			
+
+	T_message* message_org;
+   	message_org=new T_message[nStates];
+
+	int x1=x,y1=y; // get the destination
+	switch(direction){
+		case 0:
+			x1++;
+			s=Im_s.data()[offset*2+plane];
+			d=Im_d.data()[offset*2+plane];
+			break;
+		case 1:
+			x1--;
+			s=Im_s.data()[(offset-1)*2+plane];
+			d=Im_d.data()[(offset-1)*2+plane];
+			break;
+		case 2:
+			y1++;
+			s=Im_s.data()[offset*2+plane];
+			d=Im_d.data()[offset*2+plane];
+			break;
+		case 3:
+			y1--;
+			s=Im_s.data()[(offset-Width)*2+plane];
+			d=Im_d.data()[(offset-Width)*2+plane];
+			break;
+	}
+	//s=m_s;
+	//d=m_d;
+	int offset1=y1*Width+x1;
+	int nStates1=pWinSize[plane][offset1]*2+1; // get the number of states for the destination node
+	int wsize=pWinSize[plane][offset];
+	int wsize1=pWinSize[plane][offset1];
+
+	T_message*& message=pSpatialMessage[plane][offset1*nNeighbors+direction].data();
+
+	// initialize the message from the dual plane
+	if(!IsTRW)
+		memcpy(message_org,pDualMessage[plane][offset].data(),sizeof(T_message)*nStates);
+	else
+	{
+		memset(message_org,0,sizeof(T_message)*nStates);
+		Add2Message(message_org,pDualMessage[plane][offset].data(),nStates,CTRW);
+	}
+
+	// add the range term
+	if(!IsTRW)
+		Add2Message(message_org,pRangeTerm[plane][offset].data(),nStates);
+	else
+		Add2Message(message_org,pRangeTerm[plane][offset].data(),nStates,CTRW);
+	
+	// add spatial messages
+	if(!IsTRW)
+	{
+		if(x>0 && direction!=1) // add left to right
+			Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors].data(),nStates);
+		if(x<Width-1 && direction!=0) // add right to left 
+			Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+1].data(),nStates);
+		if(y>0 && direction!=3) // add top down
+			Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+2].data(),nStates);
+		if(y<Height-1 && direction!=2) // add bottom up
+			Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+3].data(),nStates);
+	}
+	else
+	{
+		if(x>0) // add left to right
+			if(direction==1)
+				Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors].data(),nStates,CTRW-1);
+			else
+				Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors].data(),nStates,CTRW);
+		if(x<Width-1) // add right to left 
+			if(direction==0)
+				Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+1].data(),nStates,CTRW-1);
+			else
+				Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+1].data(),nStates,CTRW);
+		if(y>0) // add top down
+			if(direction==3)
+				Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+2].data(),nStates,CTRW-1);
+			else
+				Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+2].data(),nStates,CTRW);
+		if(y<Height-1) // add bottom up
+			if(direction==2)
+				Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+3].data(),nStates,CTRW-1);
+			else
+				Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+3].data(),nStates,CTRW);
+	}
+	// use distance transform function to impose smoothness compatibility
+	T_message Min=CStochastic::Min(nStates,message_org)+d;
+	for(ptrdiff_t l=1;l<nStates;l++)
+		message_org[l]=__min(message_org[l],message_org[l-1]+s);
+	for(ptrdiff_t l=nStates-2;l>=0;l--)
+		message_org[l]=__min(message_org[l],message_org[l+1]+s);
+
+
+	// transform the compatibility 
+	int shift=pOffset[plane][offset1]-pOffset[plane][offset];
+	if(abs(shift)>wsize+wsize1) // the shift is too big that there is no overlap
+	{
+		if(offset>0)
+			for(ptrdiff_t l=0;l<nStates1;l++)
+				message[l]=l*s;
+		else
+			for(ptrdiff_t l=0;l<nStates1;l++)
+				message[l]=-l*s;
+	}
+	else
+	{
+		int start=__max(-wsize,shift-wsize1);
+		int end=__min(wsize,shift+wsize1);
+		for(ptrdiff_t i=start;i<=end;i++)
+			message[i-shift+wsize1]=message_org[i+wsize];
+		if(start-shift+wsize1>0)
+			for(ptrdiff_t i=start-shift+wsize1-1;i>=0;i--)
+				message[i]=message[i+1]+s;
+		if(end-shift+wsize1<nStates1)
+			for(ptrdiff_t i=end-shift+wsize1+1;i<nStates1;i++)
+				message[i]=message[i-1]+s;
+	}
+
+	// put back the threshold
+	for(ptrdiff_t l=0;l<nStates1;l++)
+		message[l]=__min(message[l],Min);
+
+	// normalize the message by subtracting the minimum value
+	Min=CStochastic::Min(nStates1,message);
+	for(ptrdiff_t l=0;l<nStates1;l++)
+		message[l]-=Min;
+
+	delete message_org;
+}
+
+template<class T>
+void BPFlow::Add2Message(T* message,const T* other,int nstates)
+{
+	for(size_t i=0;i<nstates;i++)
+		message[i]+=other[i];
+}
+
+template<class T>
+void BPFlow::Add2Message(T* message,const T* other,int nstates,double Coeff)
+{
+	for(size_t i=0;i<nstates;i++)
+		message[i]+=other[i]*Coeff;
+}
+
+//------------------------------------------------------------------------------------------------
+// update dual message passing from one plane to the other
+//------------------------------------------------------------------------------------------------
+void BPFlow::UpdateDualMessage(int x, int y, int plane)
+{
+	int offset=y*Width+x;
+	int offset1=offset;
+	int wsize=pWinSize[plane][offset];
+	int nStates=wsize*2+1;
+	int wsize1=pWinSize[1-plane][offset];
+	int nStates1=wsize1*2+1;
+
+	s=Im_s.data()[offset*2+plane];
+	d=Im_d.data()[offset*2+plane];
+	//s=m_s;
+	//d=m_d;
+
+	T_message* message_org;
+	message_org=new T_message[nStates];
+	memset(message_org,0,sizeof(T_message)*nStates);
+	
+	// add the range term
+	if(!IsTRW)
+		Add2Message(message_org,pRangeTerm[plane][offset].data(),nStates);
+	else
+		Add2Message(message_org,pRangeTerm[plane][offset].data(),nStates,CTRW);
+
+	// add spatial messages
+	if(x>0)  //add left to right
+	{
+		if(!IsTRW)
+			Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors].data(),nStates);
+		else
+			Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors].data(),nStates,CTRW);
+	}
+	if(x<Width-1) // add right to left
+	{
+		if(!IsTRW)
+			Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+1].data(),nStates);
+		else
+			Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+1].data(),nStates,CTRW);
+	}
+	if(y>0) // add top down
+	{
+		if(!IsTRW)
+			Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+2].data(),nStates);
+		else
+			Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+2].data(),nStates,CTRW);
+	}
+	if(y<Height-1) // add bottom up
+	{
+		if(!IsTRW)
+			Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+3].data(),nStates);
+		else
+			Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+2].data(),nStates,CTRW);
+	}
+
+	if(IsTRW)
+		Add2Message(message_org,pDualMessage[plane][offset1].data(),nStates,CTRW-1);
+
+	T_message*& message=pDualMessage[1-plane][offset1].data();
+
+	T_message Min;
+	// use the data term
+	if(plane==0) // from vx plane to vy plane
+		for(size_t l=0;l<nStates1;l++)
+			message[l]=CStochastic::Min(nStates,pDataTerm[offset].data()+l*nStates,message_org);
+	else					// from vy plane to vx plane
+		for(size_t l=0;l<nStates1;l++)
+		{
+			Min=message_org[0]+pDataTerm[offset].data()[l];
+			for(size_t h=0;h<nStates;h++)
+				Min=__min(Min,message_org[h]+pDataTerm[offset].data()[h*nStates1+l]);
+			message[l]=Min;
+		}
+
+	// normalize the message
+	Min=CStochastic::Min(nStates1,message);
+	for(size_t l=0;l<nStates;l++)
+		message[l]-=Min;
+
+	delete message_org;
+}
+
+//------------------------------------------------------------------------------------------------
+// compute belief
+//------------------------------------------------------------------------------------------------
+void BPFlow::ComputeBelief()
+{
+	for(size_t plane=0;plane<2;plane++)
+	{
+		memset(ptrBelief[plane],0,sizeof(T_message)*nTotalBelifElements[plane]);
+		for(size_t i=0;i<Height;i++)
+			for(size_t j=0;j<Width;j++)
+			{
+				size_t offset=i*Width+j;
+				T_message* belief=pBelief[plane][offset].data();
+				int nStates=pWinSize[plane][offset]*2+1;
+				// add range term
+				Add2Message(belief,pRangeTerm[plane][offset].data(),nStates);
+				// add message from the dual layer
+				Add2Message(belief,pDualMessage[plane][offset].data(),nStates);
+				if(j>0)
+					Add2Message(belief,pSpatialMessage[plane][offset*nNeighbors].data(),nStates);
+				if(j<Width-1)
+					Add2Message(belief,pSpatialMessage[plane][offset*nNeighbors+1].data(),nStates);
+				if(i>0)
+					Add2Message(belief,pSpatialMessage[plane][offset*nNeighbors+2].data(),nStates);
+				if(i<Height-1)
+					Add2Message(belief,pSpatialMessage[plane][offset*nNeighbors+3].data(),nStates);
+			}
+	}
+}
+
+void BPFlow::FindOptimalSolution()
+{
+	for(size_t plane=0;plane<2;plane++)
+		for(size_t i=0;i<Area;i++)
+		{
+			int nStates=pWinSize[plane][i]*2+1;
+			double Min;
+			int index=0;
+			T_message* belief=pBelief[plane][i].data();
+			Min=belief[0];
+			for(int l=1;l<nStates;l++)
+				if(Min>belief[l])
+				{
+					Min=belief[l];
+					index=l;
+				}
+			pX[i*2+plane]=index;
+		}
+}
+
+//void BPFlow::FindOptimalSolutionSequential()
+//{
+//	for(size_t plane=0;plane<2;plane++)
+//		memset(ptrBelief[plane],0,sizeof(T_message)*nTotalBelifElements[plane]);
+//
+//	for(size_t i=0;i<Height;i++)
+//		for(size_t j=0;j<Width;j++)
+//			for(size_t plane=0;plane<2;plane++)
+//			{
+//				int nStates=pWinSize[plane][i]*2+1;
+//				size_t offset=i*Width+j;
+//				T_message* belief=pBelief[plane][offset].data();
+//				
+//				// add range term
+//				Add2Message(belief,pRangeTerm[plane][offset].data(),nStates);
+//				// add message from the dual layer
+//				Add2Message(belief,pDualMessage[plane][offset].data(),nStates);
+//
+//				if(j>0) // horizontal energy
+//					for(int l=0;l<nStates;l++)
+//						belief[l]+=__min((double)abs(l-pWinSize[plane][offset]+pOffset[plane][offset]-pX[(offset-1)*2+plane]+pWinSize[plane][offset-1]-pOffset[plane][offset+1])*s,d);
+//				if(i>0) // vertical energy
+//					for(int l=0;l<nStates;l++)
+//						belief[l]+=__min((double)abs(l-pWinSize[plane][offset]+pOffset[plane][offset]-pX[(offset-Width)*2+plane]+pWinSize[plane][offset-Width]-pOffset[plane][offset-Width])*s,d);
+//				if(j<Width-1)
+//					Add2Message(belief,pSpatialMessage[plane][offset*nNeighbors+1].data(),nStates);
+//				if(i<Height-1)
+//					Add2Message(belief,pSpatialMessage[plane][offset*nNeighbors+3].data(),nStates);
+//
+//				// find the minimum
+//			int index=0;
+//			double Min=belief[0];
+//			for(int l=1;l<nStates;l++)
+//				if(Min>belief[l])
+//				{
+//					Min=belief[l];
+//					index=l;
+//				}
+//			pX[offset*2+plane]=index;
+//			}
+//}
+
+void BPFlow::FindOptimalSolutionSequential()
+{
+	for(size_t plane=0;plane<2;plane++)
+		memset(ptrBelief[plane],0,sizeof(T_message)*nTotalBelifElements[plane]);
+
+	for(size_t i=0;i<Height;i++)
+		for(size_t j=0;j<Width;j++)
+			for(size_t k=0;k<2;k++)
+			{
+				size_t plane;
+				if(j%2==0)
+					plane=k;
+				else
+					plane=1-k;
+
+				size_t offset=i*Width+j;
+				int nStates=pWinSize[plane][offset]*2+1;
+				T_message* belief=pBelief[plane][offset].data();
+				
+				// add range term
+				Add2Message(belief,pRangeTerm[plane][offset].data(),nStates);
+
+				if (k==0)
+					// add message from the dual layer
+					Add2Message(belief,pDualMessage[plane][offset].data(),nStates);
+				else
+					for(int l=0;l<nStates;l++)
+					{
+						if(plane==0) // if the current is horizontal plane
+							belief[l]+=pDataTerm[offset].data()[pX[offset*2+1]*nStates+l];
+						else   // if the current is vertical plane
+						{
+							int nStates1=pWinSize[1-plane][offset]*2+1;
+							belief[l]+=pDataTerm[offset].data()[l*nStates1+pX[offset*2]];
+						}
+					}
+
+				if(j>0) // horizontal energy
+					for(int l=0;l<nStates;l++)
+						belief[l]+=__min((double)abs(l-pWinSize[plane][offset]+pOffset[plane][offset]-pX[(offset-1)*2+plane]+pWinSize[plane][offset-1]-pOffset[plane][offset+1])*s,d);
+				if(i>0) // vertical energy
+					for(int l=0;l<nStates;l++)
+						belief[l]+=__min((double)abs(l-pWinSize[plane][offset]+pOffset[plane][offset]-pX[(offset-Width)*2+plane]+pWinSize[plane][offset-Width]-pOffset[plane][offset-Width])*s,d);
+				if(j<Width-1)
+					Add2Message(belief,pSpatialMessage[plane][offset*nNeighbors+1].data(),nStates);
+				if(i<Height-1)
+					Add2Message(belief,pSpatialMessage[plane][offset*nNeighbors+3].data(),nStates);
+
+				// find the minimum
+				int index=0;
+				double Min=belief[0];
+				for(int l=1;l<nStates;l++)
+					if(Min>belief[l])
+					{
+						Min=belief[l];
+						index=l;
+					}
+				pX[offset*2+plane]=index;
+			}
+}
+
+//------------------------------------------------------------------------------------------------
+// function to get energy
+//------------------------------------------------------------------------------------------------
+double BPFlow::GetEnergy()
+{
+	double energy=0;
+	for(size_t i=0;i<Height;i++)
+		for(size_t j=0;j<Width;j++)
+		{
+			size_t offset=i*Width+j;
+			for(size_t k=0;k<2;k++)
+			{
+				if(j<Width-1)
+				{
+					s=Im_s.data()[offset*2+k];
+					d=Im_d.data()[offset*2+k];
+					//s=m_s;
+					//d=m_d;
+					energy+=__min((double)abs(pX[offset*2+k]-pWinSize[k][offset]+pOffset[k][offset]-pX[(offset+1)*2+k]+pWinSize[k][offset+1]-pOffset[k][offset+1])*s,d);
+				}
+				if(i<Height-1)
+				{
+					s=Im_s.data()[offset*2+k];
+					d=Im_d.data()[offset*2+k];
+					//s=m_s;
+					//d=m_d;
+					energy+=__min((double)abs(pX[offset*2+k]-pWinSize[k][offset]+pOffset[k][offset]-pX[(offset+Width)*2+k]+pWinSize[k][offset+Width]-pOffset[k][offset+Width])*s,d);
+				}
+			}
+			int vx=pX[offset*2];
+			int vy=pX[offset*2+1];
+			int nStates=pWinSize[0][offset]*2+1;
+			energy+=pDataTerm[offset].data()[vy*nStates+vx];
+			for(size_t k=0;k<2;k++)
+				energy+=pRangeTerm[k][offset].data()[pX[offset*2+k]];
+		}
+	return energy;
+}
+
+void BPFlow::ComputeVelocity()
+{
+	mFlow.allocate(Width,Height,2);
+	for(int i=0;i<Area;i++)
+	{
+		mFlow.data()[i*2]=pX[i*2]+pOffset[0][i]-pWinSize[0][i];
+		mFlow.data()[i*2+1]=pX[i*2+1]+pOffset[1][i]-pWinSize[1][i];
+	}
+}
+
+//------------------------------------------------------------------------------------------------
+// multi-grid belie propagation
+//------------------------------------------------------------------------------------------------
+void BPFlow::generateCoarserLevel(BPFlow &bp)
+{
+	//------------------------------------------------------------------------------------------------
+	// set the dimensions and parameters
+	//------------------------------------------------------------------------------------------------
+	bp.Width=Width/2;
+	if(Width%2==1)
+		bp.Width++;
+
+	bp.Height=Height/2;
+	if(Height%2==1)
+		bp.Height++;
+
+	bp.Area=bp.Width*bp.Height;
+	bp.s=s;
+	bp.d=d;
+
+	DImage foo;
+	Im_s.smoothing(foo);
+	foo.imresize(bp.Im_s,bp.Width,bp.Height);
+	Im_d.smoothing(foo);
+	foo.imresize(bp.Im_d,bp.Width,bp.Height);
+
+	bp.IsDisplay=IsDisplay;
+	bp.nNeighbors=nNeighbors;
+
+	//------------------------------------------------------------------------------------------------
+	// allocate buffers
+	//------------------------------------------------------------------------------------------------
+	for(int i=0;i<2;i++)
+	{
+		bp.pOffset[i]=new int[bp.Area];
+		bp.pWinSize[i]=new int[bp.Area];
+		ReduceImage(bp.pOffset[i],Width,Height,pOffset[i]);
+		ReduceImage(bp.pWinSize[i],Width,Height,pWinSize[i]);
+	}
+	//------------------------------------------------------------------------------------------------
+	// generate data term
+	//------------------------------------------------------------------------------------------------
+	bp.nTotalMatches=bp.AllocateBuffer(bp.pDataTerm,bp.ptrDataTerm,bp.pWinSize[0],bp.pWinSize[1]);
+	for(int i=0;i<bp.Height;i++)
+		for(int j=0;j<bp.Width;j++)
+		{
+			int offset=i*bp.Width+j;
+			for(int ii=0;ii<2;ii++)
+				for(int jj=0;jj<2;jj++)
+				{
+					int y=i*2+ii;
+					int x=j*2+jj;
+					if(y<Height && x<Width)
+					{
+						int nStates=(bp.pWinSize[0][offset]*2+1)*(bp.pWinSize[1][offset]*2+1);
+						for(int k=0;k<nStates;k++)
+							bp.pDataTerm[offset].data()[k]+=pDataTerm[y*Width+x].data()[k];
+					}
+				}
+		}
+	//------------------------------------------------------------------------------------------------
+	// generate range term
+	//------------------------------------------------------------------------------------------------
+	bp.ComputeRangeTerm(gamma/2);
+}
+
+void BPFlow::propagateFinerLevel(BPFlow &bp)
+{
+	for(int i=0;i<bp.Height;i++)
+		for(int j=0;j<bp.Width;j++)
+		{
+			int y=i/2;
+			int x=j/2;
+			int nStates1=pWinSize[0][y*Width+x]*2+1;
+			int nStates2=pWinSize[1][y*Width+x]*2+1;
+			for(int k=0;k<2;k++)
+			{
+				memcpy(bp.pDualMessage[k][i*bp.Width+j].data(),pDualMessage[k][y*Width+x].data(),sizeof(T_message)*(pWinSize[k][y*Width+x]*2+1));
+				for(int l=0;l<nNeighbors;l++)
+					memcpy(bp.pSpatialMessage[k][(i*bp.Width+j)*nNeighbors+l].data(),pSpatialMessage[k][(y*Width+x)*nNeighbors+l].data(),sizeof(T_message)*(pWinSize[k][y*Width+x]*2+1));
+			}
+		}
+}
+
+template<class T>
+void BPFlow::ReduceImage(T* pDstData,int width,int height,const T *pSrcData)
+{
+	int DstWidth=width/2;
+	if(width%2==1)
+		DstWidth++;
+	int DstHeight=height/2;
+	if(height%2==1)
+		DstHeight++;
+	memset(pDstData,0,sizeof(T)*DstWidth*DstHeight);
+	int sum=0;
+	for(int i=0;i<DstHeight;i++)
+		for(int j=0;j<DstWidth;j++)
+		{
+			int offset=i*DstWidth+j;
+			sum=0;
+			for(int ii=0;ii<2;ii++)
+				for(int jj=0;jj<2;jj++)
+				{
+					int x=j*2+jj;
+					int y=i*2+ii;
+					if(y<height && x<width)
+					{
+						pDstData[offset]+=pSrcData[y*width+x];
+						sum++;
+					}
+				}
+			pDstData[offset]/=sum;
+		}
+}

UVDoc_official/eval/eval_code/SIFTflow/mexDiscreteFlow/BPFlow.h

@@ -0,0 +1,246 @@
+#pragma once
+
+#include "memory.h"
+#include "Image.h"
+
+typedef int T_state;					// T_state is the type for state
+typedef unsigned char T_input;			// T_input is the data type of the input image
+// T_message is the data type of the messages and beliefs
+//typedef double T_message;  
+#define INTMESSAGE
+#ifdef INTMESSAGE
+	typedef int T_message;
+#else
+	typedef double T_message;
+#endif
+
+//-----------------------------------------------------------------------------------
+// class for 1D pixel buffer
+//-----------------------------------------------------------------------------------
+template <class T>
+class PixelBuffer1D
+{
+private:
+	short int nDim;
+	T* pData;
+public:
+	PixelBuffer1D(void)
+	{
+		nDim=0;
+		pData=NULL;
+	}
+	PixelBuffer1D(int ndims)
+	{
+		allocate(ndims);
+	}
+	void allocate(int ndims)
+	{
+		nDim=ndims;
+	}
+	~PixelBuffer1D()
+	{
+		nDim=0;
+		pData=NULL;
+	}
+	inline const T operator [](int index) const
+	{
+		return pData[index];
+	}
+	inline T& operator [](int index)
+	{
+		return pData[index];
+	}
+	T*& data(){return pData;};
+	const T* data() const{return pData;};
+	int nElements() const{return nDim;};
+};
+
+//-----------------------------------------------------------------------------------
+// class for 2D pixel buffer
+//-----------------------------------------------------------------------------------
+template <class T>
+class PixelBuffer2D
+{
+private:
+	short int nDimX,nDimY;
+	T* pData;
+public:
+	PixelBuffer2D(void)
+	{
+		nDimX=nDimY=0;
+		pData=NULL;
+	}
+	PixelBuffer2D(int ndimx,int ndimy)
+	{
+		allocate(ndimx,ndimy);
+	}
+	void allocate(int ndimx,int ndimy)
+	{
+		nDimX=ndimx;
+		nDimY=ndimy;
+		pData=NULL;
+	}
+	~PixelBuffer2D()
+	{
+		nDimX=nDimY=0;
+		pData=NULL;
+	}
+	inline const T operator [](int index) const
+	{
+		return pData[index];
+	}
+	inline T& operator [](int index)
+	{
+		return pData[index];
+	}
+	T*& data(){return pData;};
+	const T* data() const{return pData;};
+	int nElements()const{return nDimX*nDimY;};
+};
+
+//-----------------------------------------------------------------------------------
+// the class for BP flow
+//-----------------------------------------------------------------------------------
+class BPFlow
+{
+private:
+	bool IsDisplay;
+	bool IsDataTermTruncated;
+	bool IsTRW;
+	double CTRW;
+
+	size_t Height,Width,Area,nChannels;
+    size_t Height2,Width2;
+    
+	T_input *pIm1,*pIm2;   // the two images for matching
+
+	int *pOffset[2]; // the predicted flow 
+	int *pWinSize[2];// the dimension of the matching size
+	size_t nTotalMatches;
+
+	// the buffers for belief propagation
+	PixelBuffer2D<T_message>* pDataTerm;					// the data term
+	PixelBuffer1D<T_message>* pRangeTerm[2];               // the range term
+	PixelBuffer1D<T_message>* pSpatialMessage[2];      // the spatial message
+	PixelBuffer1D<T_message>* pDualMessage[2];            // the dual message between two layers
+	PixelBuffer1D<T_message>* pBelief[2];							// the belief
+
+	T_message *ptrDataTerm;
+	T_message *ptrRangeTerm[2];
+	T_message* ptrSpatialMessage[2];
+	T_message *ptrDualMessage[2];
+	T_message* ptrBelief[2];
+
+	size_t nTotalSpatialElements[2];
+	size_t nTotalDualElements[2];
+	size_t nTotalBelifElements[2];
+
+	int *pX; // the final states
+
+	DImage mFlow; // the flow field
+
+	int nNeighbors;
+	double s,d,gamma;   // the parameters of regularization
+	//double m_s,m_d;
+	DImage Im_s,Im_d;  // per pixel parameterization
+public:
+	BPFlow(void);
+	~BPFlow(void);
+	void ReleaseBuffer();
+	void setPara(double _s,double _d);
+	void setPara(const DImage& im_s,const DImage& im_d){Im_s=im_s;Im_d=im_d;};
+	void setDataTermTruncation(bool isTruncated){IsDataTermTruncated=isTruncated;};
+	void setDisplay(bool isDisplay){IsDisplay=isDisplay;};
+	void setTRW(bool isTRW){IsTRW=isTRW;};
+	void setCTRW(double cTRW){CTRW=cTRW;};
+	void LoadImages(int _width,int _height,int _nchannels,const T_input* pImage1,const T_input* pImage2);
+	void LoadImages(int _width,int _height,int _nchannels,const T_input* pImage1,
+                                        int _width2,int _height2,const T_input* pImage2);
+    
+	void setHomogeneousMRF(int winSize);
+	
+	template<class T>
+	void LoadOffset(T* pOffsetX,T* pOffsetY);
+	template <class T>
+	void LoadWinSize(T* pWinSizeX,T* pWinSizeY);
+
+	void ComputeDataTerm();
+	void ComputeRangeTerm(double _gamma);
+	void AllocateMessage();
+	double MessagePassing(int nIterations,int nHierarchy,double* pEnergyList=NULL);
+	void Bipartite(int count);
+	void BP_S(int count);
+	void TRW_S(int count);
+	
+	template<class T>
+	bool InsideImage(T x,T y);
+
+	template<class T1,class T2>
+	size_t AllocateBuffer(T1*& pBuffer,size_t factor,T2*& ptrData,const int* pWinSize);
+
+	template<class T1,class T2>
+	size_t AllocateBuffer(T1*& pBuffer,T2*& ptrData,const int* pWinSize1,const int* pWinSize2);
+
+	// this is the core function for message updating
+	void UpdateSpatialMessage(int x,int y,int plane,int direction); //T_message* message);
+	
+	void UpdateDualMessage(int x,int y,int plane);
+
+	template<class T>
+	void Add2Message(T* message,const T* other,int nstates);
+
+	template<class T>
+	void Add2Message(T* message,const T* other,int nstates,double Coeff);
+
+	void ComputeBelief();
+
+	void FindOptimalSolution();
+	void FindOptimalSolutionSequential();
+
+	double GetEnergy();
+
+	const int* x() const{return pX;};
+
+	void ComputeVelocity();
+
+	const DImage& flow() const{return mFlow;};
+	DImage& flow(){return mFlow;};
+
+	//------------------------------------------------------------------------
+	// multi-grid belief propagation
+	void generateCoarserLevel(BPFlow& bp);
+	void propagateFinerLevel(BPFlow& bp);	
+		
+	template<class T>
+	void ReduceImage(T* pOutputData,int width,int height,const T* pInputData);
+};
+
+template<class T>
+void BPFlow::LoadOffset(T* pOffsetX,T* pOffsetY)
+{
+	for(int i=0;i<2;i++)
+	{
+		_Release1DBuffer(pOffset[i]);
+		pOffset[i]=new T_state[Area];
+	}
+	for(size_t j=0;j<Area;j++)
+	{
+		pOffset[0][j]=pOffsetX[j];
+		pOffset[1][j]=pOffsetY[j];
+	}
+}
+
+template<class T>
+void BPFlow::LoadWinSize(T* pWinSizeX,T* pWinSizeY)
+{
+	for(int i=0;i<2;i++)
+	{
+		_Release1DBuffer(pWinSize[i]);
+		pWinSize[i]=new T_state[Area];
+	}
+	for(size_t j=0;j<Area;j++)
+	{
+		pWinSize[0][j]=pWinSizeX[j];
+		pWinSize[1][j]=pWinSizeY[j];
+	}
+}

UVDoc_official/eval/eval_code/SIFTflow/mexDiscreteFlow/Image.h

@@ -0,0 +1,1574 @@
+#ifndef _Image_h
+#define _Image_h
+
+#include "project.h"
+#include "stdio.h"
+#include "memory.h"
+#include "ImageProcessing.h"
+#include <iostream>
+
+#ifndef _MATLAB
+	#include <QFile>
+	#include <QString>
+	#include "ImageIO.h"
+#else
+	#include "mex.h"
+#endif
+
+using namespace std;
+
+// template class for image
+template <class T>
+class Image
+{
+protected:
+	T* pData;
+	int imWidth,imHeight,nChannels;
+	int nPixels,nElements;
+	bool IsDerivativeImage;
+public:
+	Image(void);
+	Image(int width,int height,int nchannels=1);
+	Image(const T& value,int _width,int _height,int _nchannels=1);
+#ifndef _MATLAB
+	Image(const QImage& image);
+#endif
+	Image(const Image<T>& other);
+	~Image(void);
+	virtual Image<T>& operator=(const Image<T>& other);
+
+	virtual inline void computeDimension(){nPixels=imWidth*imHeight;nElements=nPixels*nChannels;};
+
+	virtual void allocate(int width,int height,int nchannels=1);
+	
+	template <class T1>
+	void allocate(const Image<T1>& other);
+
+	virtual void clear();
+	virtual void reset();
+	virtual void copyData(const Image<T>& other);
+	void setValue(const T& value);
+	void setValue(const T& value,int _width,int _height,int _nchannels=1);
+	T max() const{
+		T Max=pData[0];
+		for(int i=1;i<nElements;i++)
+			Max=__max(Max,pData[i]);
+		return Max;
+	};
+	T min() const{
+		T Min=pData[0];
+		for(int i=1;i<nElements;i++)
+			Min=__min(Min,pData[i]);
+		return Min;
+	}
+	template <class T1>
+	void copy(const Image<T1>& other);
+
+	void im2double();
+
+	// function to access the member variables
+	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;};
+	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<imWidth && y>=0 && y<imHeight) return true; else return false;};
+
+	template <class T1>
+	bool matchDimension  (const Image<T1>& image) const;
+
+	bool matchDimension (int width,int height,int nchannels) const;
+
+	inline void setDerivative(bool isDerivativeImage=true){IsDerivativeImage=isDerivativeImage;};
+
+	// function to move this image to another one
+	template <class T1>
+	void moveto(Image<T1>& image,int x,int y,int width=0,int height=0);
+
+	// function of basic image operations
+	virtual bool imresize(double ratio);
+	template <class T1>
+	void imresize(Image<T1>& result,double ratio) const;
+	void imresize(int dstWidth,int dstHeight);
+	template <class T1>
+	void imresize(Image<T1>& result,int dstWidth,int dstHeight) const;
+
+#ifndef _MATLAB
+	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 <class T1>
+	Image<T1> dx(bool IsAdvancedFilter=false) const;
+
+	template <class T1>
+	void dx(Image<T1>& image,bool IsAdvancedFilter=false) const;
+
+	template<class T1>
+	Image<T1> dy(bool IsAdvancedFilter=false) const;
+
+	template <class T1>
+	void dy(Image<T1>& image,bool IsAdvancedFilter=false) const;
+
+	template <class T1>
+	void dxx(Image<T1>& image) const;
+
+	template <class T1>
+	void dyy(Image<T1>& image) const;
+
+	template <class T1>
+	void laplacian(Image<T1>& image) const;
+
+	template <class T1>
+	void gradientmag(Image<T1>& image) const;
+
+	template <class T1>
+	void GaussianSmoothing(Image<T1>& image,double sigma,int fsize) const;
+
+	template <class T1>
+	void smoothing(Image<T1>& image,double factor=4);
+
+	template <class T1>
+	Image<T1> smoothing(double factor=4);
+
+	void smoothing(double factor=4);
+
+	// funciton for filtering
+	template <class T1>
+	void imfilter(Image<T1>& image,double* filter,int fsize) const;
+
+	template <class T1>
+	Image<T1> imfilter(double* filter,int fsize);
+
+	template <class T1>
+	void imfilter_h(Image<T1>& image,double* filter,int fsize) const;
+
+	template <class T1>
+	void imfilter_v(Image<T1>& image,double* filter,int fsize) const;
+
+	template <class T1>
+	void imfilter_hv(Image<T1>& image,double* hfilter,int hfsize,double* vfilter,int vfsize) const;
+
+	// function to desaturating
+	template <class T1>
+	void desaturate(Image<T1>& image) const;
+
+	void desaturate();
+
+	template <class T1>
+	void collapse(Image<T1>& image) const;
+
+	// function to concatenate images
+	template <class T1,class T2>
+	void concatenate(Image<T1>& destImage,const Image<T2>& addImage) const;
+
+	template <class T1,class T2>
+	void concatenate(Image<T1>& destImage,const Image<T2>& addImage,double ratio) const;
+
+	template <class T1>
+	Image<T> concatenate(const Image<T1>& addImage) const;
+
+	// function to separate the channels of the image
+	template <class T1,class T2>
+	void separate(unsigned firstNChannels,Image<T1>& image1,Image<T2>& image2) const;
+
+	// function to sample patch
+	template <class T1>
+	void getPatch(Image<T1>& patch,double x,double y,int fsize) const;
+
+	// function to crop the image
+	template <class T1>
+	void crop(Image<T1>& patch,int Left,int Top,int Width,int Height) const;
+
+	// basic numerics of images
+	template <class T1,class T2>
+	void Multiply(const Image<T1>& image1,const Image<T2>& image2);
+
+	template <class T1,class T2,class T3>
+	void Multiply(const Image<T1>& image1,const Image<T2>& image2,const Image<T3>& image3);
+
+	template <class T1>
+	void Multiplywith(const Image<T1>& image1);
+
+	void Multiplywith(double value);
+
+	template <class T1,class T2>
+	void Add(const Image<T1>& image1,const Image<T2>& image2);
+
+	template <class T1,class T2>
+	void Add(const Image<T1>& image1,const Image<T2>& image2,double ratio);
+
+	void Add(const T value);
+
+	template <class T1>
+	void Add(const Image<T1>& image1,const double value);
+
+	template <class T1>
+	void Add(const Image<T1>& image1);
+
+	template <class T1,class T2>
+	void Subtract(const Image<T1>& image1,const Image<T2>& image2);
+
+	// function to normalize an image
+	void normalize(Image<T>& image);
+
+	// function to compute the statistics of the image
+	double norm2() const;
+
+	template <class T1>
+	double innerproduct(Image<T1>& image) const;
+
+	// function to bilateral smooth flow field
+	template <class T1>
+	void BilateralFiltering(Image<T1>& other,int fsize,double filter_signa,double range_sigma);
+
+	// file IO
+#ifndef _MATLAB
+	bool writeImage(QFile& file) const;
+	bool readImage(QFile& file);
+	bool writeImage(const QString& filename) const;
+	bool readImage(const QString& filename);
+#endif
+
+#ifdef _MATLAB
+	bool LoadMatlabImage(const mxArray* image,bool IsImageScaleCovnersion=true);
+	template <class T1>
+	void LoadMatlabImageCore(const mxArray* image,bool IsImageScaleCovnersion=true);
+
+	template <class T1>
+	void ConvertFromMatlab(const T1* pMatlabPlane,int _width,int _height,int _nchannels);
+
+	void OutputToMatlab(mxArray*& matrix);
+
+	template <class T1>
+	void ConvertToMatlab(T1* pMatlabPlane);
+#endif
+};
+
+
+typedef Image<unsigned char> BiImage;
+typedef Image<short int> IntImage;
+typedef Image<float> FImage;
+typedef Image<double> DImage;
+
+//------------------------------------------------------------------------------------------
+// constructor
+//------------------------------------------------------------------------------------------
+template <class T>
+Image<T>::Image()
+{
+	pData=NULL;
+	imWidth=imHeight=nChannels=nPixels=nElements=0;
+	IsDerivativeImage=false;
+}
+
+//------------------------------------------------------------------------------------------
+// constructor with specified dimensions
+//------------------------------------------------------------------------------------------
+template <class T>
+Image<T>::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 <class T>
+Image<T>::Image(const T& value,int _width,int _height,int _nchannels)
+{
+	pData=NULL;
+	allocate(_width,_height,_nchannels);
+	setValue(value);
+}
+
+#ifndef _MATLAB
+template <class T>
+Image<T>::Image(const QImage& image)
+{
+	pData=NULL;
+	imread(image);
+}
+#endif
+
+template <class T>
+void Image<T>::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 <class T>
+template <class T1>
+void Image<T>::allocate(const Image<T1> &other)
+{
+	allocate(other.width(),other.height(),other.nchannels());
+}
+
+//------------------------------------------------------------------------------------------
+// copy constructor
+//------------------------------------------------------------------------------------------
+template <class T>
+Image<T>::Image(const Image<T>& other)
+{
+	imWidth=imHeight=nChannels=nElements=0;
+	pData=NULL;
+	copyData(other);
+}
+
+//------------------------------------------------------------------------------------------
+// destructor
+//------------------------------------------------------------------------------------------
+template <class T>
+Image<T>::~Image()
+{
+	if(pData!=NULL)
+		delete []pData;
+}
+
+//------------------------------------------------------------------------------------------
+// clear the image
+//------------------------------------------------------------------------------------------
+template <class T>
+void Image<T>::clear()
+{
+	if(pData!=NULL)
+		delete []pData;
+	pData=NULL;
+	imWidth=imHeight=nChannels=nPixels=nElements=0;
+}
+
+//------------------------------------------------------------------------------------------
+// reset the image (reset the buffer to zero)
+//------------------------------------------------------------------------------------------
+template <class T>
+void Image<T>::reset()
+{
+	if(pData!=NULL)
+		memset(pData,0,sizeof(T)*nElements);
+}
+
+template <class T>
+void Image<T>::setValue(const T &value)
+{
+	for(int i=0;i<nElements;i++)
+		pData[i]=value;
+}
+
+template <class T>
+void Image<T>::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 <class T>
+void Image<T>::copyData(const Image<T>& other)
+{
+	imWidth=other.imWidth;
+	imHeight=other.imHeight;
+	nChannels=other.nChannels;
+	nPixels=other.nPixels;
+	IsDerivativeImage=other.IsDerivativeImage;
+
+	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 <class T>
+template <class T1>
+void Image<T>::copy(const Image<T1>& other)
+{
+	clear();
+
+	imWidth=other.width();
+	imHeight=other.height();
+	nChannels=other.nchannels();
+	computeDimension();
+
+	IsDerivativeImage=other.isDerivativeImage();
+
+	pData=NULL;
+	pData=new T[nElements];
+	const T1*& srcData=other.data();
+	for(int i=0;i<nElements;i++)
+		pData[i]=srcData[i];
+}
+
+template <class T>
+void Image<T>::im2double()
+{
+	if(IsFloat())
+		for(int i=0;i<nElements;i++)
+			pData[i]/=255;
+}
+
+//------------------------------------------------------------------------------------------
+// override equal operator
+//------------------------------------------------------------------------------------------
+template <class T>
+Image<T>& Image<T>::operator=(const Image<T>& other)
+{
+	copyData(other);
+	return *this;
+}
+
+template <class T>
+bool Image<T>::IsFloat() const
+{
+	if(typeid(T)==typeid(float) || typeid(T)==typeid(double) || typeid(T)==typeid(long double))
+		return true;
+	else
+		return false;
+}
+
+template <class T>
+template <class T1>
+bool Image<T>::matchDimension(const Image<T1>& image) const
+{
+	if(imWidth==image.width() && imHeight==image.height() && nChannels==image.nchannels())
+		return true;
+	else
+		return false;
+}
+
+template <class T>
+bool Image<T>::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 <class T>
+template <class T1>
+void Image<T>::moveto(Image<T1>& 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<height;i++)
+	{
+		y=y0+i;
+		if(y>=image.height())
+			break;
+		for(int j=0;j<width;j++)
+		{
+			x=x0+j;
+			if(x>=image.width())
+				break;
+			for(int k=0;k<NChannels;k++)
+				image.data()[(y*image.width()+x)*image.nchannels()+k]=pData[(i*imWidth+j)*nChannels+k];
+		}
+	}
+}
+
+
+//------------------------------------------------------------------------------------------
+// resize the image
+//------------------------------------------------------------------------------------------
+template <class T>
+bool Image<T>::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 <class T>
+template <class T1>
+void Image<T>::imresize(Image<T1>& 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);
+	ImageProcessing::ResizeImage(pData,result.data(),imWidth,imHeight,nChannels,ratio);
+}
+
+template <class T>
+template <class T1>
+void Image<T>::imresize(Image<T1>& result,int DstWidth,int DstHeight) const
+{
+	if(result.width()!=DstWidth || result.height()!=DstHeight || result.nchannels()!=nChannels)
+		result.allocate(DstWidth,DstHeight,nChannels);
+	ImageProcessing::ResizeImage(pData,result.data(),imWidth,imHeight,nChannels,DstWidth,DstHeight);
+}
+
+
+template <class T>
+void Image<T>::imresize(int dstWidth,int dstHeight)
+{
+	DImage foo(dstWidth,dstHeight,nChannels);
+	ImageProcessing::ResizeImage(pData,foo.data(),imWidth,imHeight,nChannels,dstWidth,dstHeight);
+	copyData(foo);
+}
+
+//------------------------------------------------------------------------------------------
+// function to load the image
+//------------------------------------------------------------------------------------------
+#ifndef _MATLAB
+template <class T>
+bool Image<T>::imread(const QString &filename)
+{
+	clear();
+	if(ImageIO::loadImage(filename,pData,imWidth,imHeight,nChannels))
+	{
+		computeDimension();
+		return true;
+	}
+	return false;
+}
+
+template <class T>
+void Image<T>::imread(const QImage& image)
+{
+	clear();
+	ImageIO::loadImage(image,pData,imWidth,imHeight,nChannels);
+	computeDimension();
+}
+
+//------------------------------------------------------------------------------------------
+// function to write the image
+//------------------------------------------------------------------------------------------
+template <class T>
+bool Image<T>::imwrite(const QString& filename,int quality) const
+{
+	ImageIO::ImageType type;
+	if(IsDerivativeImage)
+		type=ImageIO::derivative;
+	else
+		type=ImageIO::standard;
+
+	return ImageIO::writeImage(filename,(const T*&)pData,imWidth,imHeight,nChannels,type,quality);
+}
+
+template <class T>
+bool Image<T>::imwrite(const QString &filename, ImageIO::ImageType imagetype, int quality) const
+{
+	return ImageIO::writeImage(filename,(const T*&)pData,imWidth,imHeight,nChannels,imagetype,quality);
+}
+
+template <class T>
+bool Image<T>::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 <class T>
+template <class T1>
+void Image<T>::dx(Image<T1>& 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<imHeight;i++)
+			for(j=0;j<imWidth-1;j++)
+			{
+				offset=i*imWidth+j;
+				for(k=0;k<nChannels;k++)
+					data[offset*nChannels+k]=(T1)pData[(offset+1)*nChannels+k]-pData[offset*nChannels+k];
+			}
+	else
+	{
+		double xFilter[5]={1,-8,0,8,-1};
+		for(i=0;i<5;i++)
+			xFilter[i]/=12;
+		ImageProcessing::hfiltering(pData,data,imWidth,imHeight,nChannels,xFilter,2);
+	}
+}
+
+template <class T>
+template <class T1>
+Image<T1> Image<T>::dx(bool IsAdvancedFilter) const
+{
+	Image<T1> result;
+	dx<T1>(result,IsAdvancedFilter);
+	return result;
+}
+
+//------------------------------------------------------------------------------------------
+// function to get y-derivative of the image
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::dy(Image<T1>& 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<imHeight-1;i++)
+			for(j=0;j<imWidth;j++)
+			{
+				offset=i*imWidth+j;
+				for(k=0;k<nChannels;k++)
+					data[offset*nChannels+k]=(T1)pData[(offset+imWidth)*nChannels+k]-pData[offset*nChannels+k];
+			}
+	else
+	{
+		double yFilter[5]={1,-8,0,8,-1};
+		for(i=0;i<5;i++)
+			yFilter[i]/=12;
+		ImageProcessing::vfiltering(pData,data,imWidth,imHeight,nChannels,yFilter,2);
+	}
+}
+
+template <class T>
+template <class T1>
+Image<T1> Image<T>::dy(bool IsAdvancedFilter) const
+{
+	Image<T1> result;
+	dy<T1>(result,IsAdvancedFilter);
+	return result;
+}
+
+//------------------------------------------------------------------------------------------
+// function to compute the second order derivative 
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::dxx(Image<T1> &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<imHeight;i++)
+			for(int j=0;j<imWidth;j++)
+			{
+				int offset=i*imWidth+j;
+				if(j==0)
+				{
+					pDstData[offset]=pData[offset]-pData[offset+1];
+					continue;
+				}
+				if(j==imWidth-1)
+				{
+					pDstData[offset]=pData[offset]-pData[offset-1];
+					continue;
+				}
+				pDstData[offset]=pData[offset]*2-pData[offset-1]-pData[offset+1];
+			}
+	else
+		for(int i=0;i<imHeight;i++)
+			for(int j=0;j<imWidth;j++)
+			{
+				int offset=(i*imWidth+j)*nChannels;
+				if(j==0)
+				{
+					for(int k=0;k<nChannels;k++)
+						pDstData[offset+k]=pData[offset+k]-pData[offset+nChannels+k];
+					continue;
+				}
+				if(j==imWidth-1)
+				{
+					for(int k=0;k<nChannels;k++)
+						pDstData[offset+k]=pData[offset+k]-pData[offset-nChannels+k];
+					continue;
+				}
+				for(int k=0;k<nChannels;k++)
+					pDstData[offset+k]=pData[offset+k]*2-pData[offset+nChannels+k]-pData[offset-nChannels+k];
+			}
+}
+
+template <class T>
+template <class T1>
+void Image<T>::dyy(Image<T1>& image) const
+{
+	if(!matchDimension(image))
+		image.allocate(imWidth,imHeight,nChannels);
+	T1* pDstData=image.data();
+	if(nChannels==1)
+		for(int i=0;i<imHeight;i++)
+			for(int j=0;j<imWidth;j++)
+			{
+				int offset=i*imWidth+j;
+				if(i==0)
+				{
+					pDstData[offset]=pData[offset]-pData[offset+imWidth];
+					continue;
+				}
+				if(i==imHeight-1)
+				{
+					pDstData[offset]=pData[offset]-pData[offset-imWidth];
+					continue;
+				}
+				pDstData[offset]=pData[offset]*2-pData[offset+imWidth]-pData[offset-imWidth];
+			}
+	else
+		for(int i=0;i<imHeight;i++)
+			for(int j=0;j<imWidth;j++)
+			{
+				int offset=(i*imWidth+j)*nChannels;
+				if(i==0)
+				{
+					for(int k=0;k<nChannels;k++)
+						pDstData[offset+k]=pData[offset+k]-pData[offset+imWidth*nChannels+k];
+					continue;
+				}
+				if(i==imHeight-1)
+				{
+					for(int k=0;k<nChannels;k++)
+						pDstData[offset+k]=pData[offset+k]-pData[offset-imWidth*nChannels+k];
+					continue;
+				}
+				for(int k=0;k<nChannels;k++)
+					pDstData[offset+k]=pData[offset+k]*2-pData[offset+imWidth*nChannels+k]-pData[offset-imWidth*nChannels+k];
+			}
+}
+
+//------------------------------------------------------------------------------------------
+// function for fast laplacian computation
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::laplacian(Image<T1> &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 <class T>
+template <class T1>
+void Image<T>::gradientmag(Image<T1> &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<nPixels;i++)
+	{
+		temp=0;
+		int offset=i*nChannels;
+		for(int k=0;k<nChannels;k++)
+		{
+			temp+=Ixdata[offset+k]*Ixdata[offset+k];
+			temp+=Iydata[offset+k]*Iydata[offset+k];
+		}
+		imagedata[i]=sqrt(temp);
+	}
+}
+
+//------------------------------------------------------------------------------------------
+// function to do Gaussian smoothing
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::GaussianSmoothing(Image<T1>& image,double sigma,int fsize) const 
+{
+	Image<T1> 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 smooth the image using a simple 3x3 filter
+// the filter is [1 factor 1]/(factor+2), applied horizontally and vertically
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::smoothing(Image<T1>& 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<T1>(image,filter2D,1);
+}
+
+template <class T>
+template <class T1>
+Image<T1> Image<T>::smoothing(double factor)
+{
+	Image<T1> result;
+	smoothing(result,factor);
+	return result;
+}
+
+template <class T>
+void Image<T>::smoothing(double factor)
+{
+	Image<T> result(imWidth,imHeight,nChannels);
+	smoothing(result,factor);
+	copyData(result);
+}
+
+//------------------------------------------------------------------------------------------
+//	 function of image filtering
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::imfilter(Image<T1>& image,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 <class T>
+template <class T1>
+Image<T1> Image<T>::imfilter(double *filter, int fsize)
+{
+	Image<T1> result;
+	imfilter(result,filter,fsize);
+	return result;
+}
+
+template <class T>
+template <class T1>
+void Image<T>::imfilter_h(Image<T1>& 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 <class T>
+template <class T1>
+void Image<T>::imfilter_v(Image<T1>& 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 <class T>
+template <class T1>
+void Image<T>::imfilter_hv(Image<T1> &image, double *hfilter, int hfsize, 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;
+}
+
+//------------------------------------------------------------------------------------------
+//	 function for desaturation
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::desaturate(Image<T1> &image) const
+{
+	if(nChannels!=3)
+	{
+		collapse(image);
+		return;
+	}
+	if(!(image.width()==imWidth && image.height()==imHeight && image.nChannels==1))
+		image.allocate(imWidth,imHeight,1);
+	T1* data=image.data();
+	int offset;
+	for(int i=0;i<nPixels;i++)
+	{
+		offset=i*3;
+		data[i]=(double)pData[offset]*.299+pData[offset+1]*.587+pData[offset+2]*.114;
+	}
+}
+
+template <class T>
+void Image<T>::desaturate()
+{
+	Image<T> temp;
+	desaturate(temp);
+	copyData(temp);
+}
+
+template <class T>
+template <class T1>
+void Image<T>::collapse(Image<T1> &image) const
+{
+	if(!(image.width()==imWidth && image.height()==imHeight && image.nChannels==1))
+		image.allocate(imWidth,imHeight,1);
+	T1* data=image.data();
+	int offset;
+	double temp;
+	for(int i=0;i<nPixels;i++)
+	{
+		offset=i*nChannels;
+		temp=0;
+		for(int j=0;j<nChannels;j++)
+			temp+=pData[offset+j];
+		data[i]=temp/nChannels;
+	}
+}
+
+//------------------------------------------------------------------------------------------
+//  function to concatenate two images
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1,class T2>
+void Image<T>::concatenate(Image<T1> &destImage, const Image<T2> &addImage) const
+{
+	if(addImage.width()!=imWidth || addImage.height()!=imHeight)
+	{
+		destImage.copy(*this);
+		return;
+	}
+	int extNChannels=nChannels+addImage.nchannels();
+	if(destImage.width()!=imWidth || destImage.height()!=imHeight || destImage.nchannels()!=extNChannels)
+		destImage.allocate(imWidth,imHeight,extNChannels);
+	int offset;
+	T1*& pDestData=destImage.data();
+	const T2*& pAddData=addImage.data();
+	for(int i=0;i<imHeight;i++)
+		for(int j=0;j<imWidth;j++)
+		{
+			offset=i*imWidth+j;
+			for(int k=0;k<nChannels;k++)
+				pDestData[offset*extNChannels+k]=pData[offset*nChannels+k];
+			for(int k=nChannels;k<extNChannels;k++)
+				pDestData[offset*extNChannels+k]=pAddData[offset*addImage.nchannels()+k-nChannels];
+		}
+}
+
+template <class T>
+template <class T1,class T2>
+void Image<T>::concatenate(Image<T1> &destImage, const Image<T2> &addImage,double ratio) const
+{
+	if(addImage.width()!=imWidth || addImage.height()!=imHeight)
+	{
+		destImage.copy(*this);
+		return;
+	}
+	int extNChannels=nChannels+addImage.nchannels();
+	if(destImage.width()!=imWidth || destImage.height()!=imHeight || destImage.nchannels()!=extNChannels)
+		destImage.allocate(imWidth,imHeight,extNChannels);
+	int offset;
+	T1*& pDestData=destImage.data();
+	const T2*& pAddData=addImage.data();
+	for(int i=0;i<imHeight;i++)
+		for(int j=0;j<imWidth;j++)
+		{
+			offset=i*imWidth+j;
+			for(int k=0;k<nChannels;k++)
+				pDestData[offset*extNChannels+k]=pData[offset*nChannels+k];
+			for(int k=nChannels;k<extNChannels;k++)
+				pDestData[offset*extNChannels+k]=pAddData[offset*addImage.nchannels()+k-nChannels]*ratio;
+		}
+}
+
+
+template <class T>
+template <class T1>
+Image<T> Image<T>::concatenate(const Image<T1> &addImage) const
+{
+	Image<T> destImage;
+	concatenate(destImage,addImage);
+	return destImage;
+}
+
+//------------------------------------------------------------------------------------------
+// function to separate the image into two
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1,class T2>
+void Image<T>::separate(unsigned int firstNChannels, Image<T1> &image1, Image<T2> &image2) const
+{
+	image1.IsDerivativeImage=IsDerivativeImage;
+	image2.IsDerivativeImage=IsDerivativeImage;
+
+	if(firstNChannels>=nChannels)
+	{
+		image1=*this;
+		image2.allocate(imWidth,imHeight,0);
+		return;
+	}
+	if(firstNChannels==0)
+	{
+		image1.allocate(imWidth,imHeight,0);
+		image2=*this;
+		return;
+	}
+	int secondNChannels=nChannels-firstNChannels;
+	if(image1.width()!=imWidth || image1.height()!=imHeight || image1.nchannels()!=firstNChannels)
+		image1.allocate(imWidth,imHeight,firstNChannels);
+	if(image2.width()!=imWidth || image2.height()!=imHeight || image2.nchannels()!=secondNChannels)
+		image2.allocate(imWidth,imHeight,secondNChannels);
+
+	for(int i=0;i<imHeight;i++)
+		for(int j=0;j<imWidth;j++)
+		{
+			int offset=i*imWidth+j;
+			for(int k=0;k<firstNChannels;k++)
+				image1.pData[offset*firstNChannels+k]=pData[offset*nChannels+k];
+			for(int k=firstNChannels;k<nChannels;k++)
+				image2.pData[offset*secondNChannels+k-firstNChannels]=pData[offset*nChannels+k];
+		}
+}
+
+//------------------------------------------------------------------------------------------
+// function to separate the image into two
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::getPatch(Image<T1>& patch,double x,double y,int wsize) const
+{
+	int wlength=wsize*2+1;
+	if(patch.width()!=wlength || patch.height()!=wlength || patch.nchannels()!=nChannels)
+		patch.allocate(wlength,wlength,nChannels);
+	else
+		patch.reset();
+	ImageProcessing::getPatch(pData,patch.data(),imWidth,imHeight,nChannels,x,y,wsize);
+}
+
+//------------------------------------------------------------------------------------------
+// function to crop an image
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1>
+void Image<T>::crop(Image<T1>& patch,int Left,int Top,int Width,int Height) const
+{
+	if(patch.width()!=Width || patch.height()!=Height || patch.nchannels()!=nChannels)
+		patch.allocate(Width,Height,nChannels);
+	// make sure that the cropping is valid
+	if(Left<0 || Top<0 || Left>=imWidth || Top>=imHeight)
+	{
+		cout<<"The cropping coordinate is outside the image boundary!"<<endl;
+		return;
+	}
+	if(Width<0 || Height<0 || Width+Left>imWidth || Height+Top>imHeight)
+	{
+		cout<<"The patch to crop is invalid!"<<endl;
+		return;
+	}
+	ImageProcessing::cropImage(pData,imWidth,imHeight,nChannels,patch.data(),Left,Top,Width,Height);
+}
+
+//------------------------------------------------------------------------------------------
+// function to multiply image1, image2 and image3 to the current image
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1,class T2,class T3>
+void Image<T>::Multiply(const Image<T1>& image1,const Image<T2>& image2,const Image<T3>& image3)
+{
+	if(image1.matchDimension(image2)==false || image2.matchDimension(image3)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Multiply()!"<<endl;
+		return;
+	}
+	if(matchDimension(image1)==false)
+		allocate(image1);
+
+	const T1*& pData1=image1.data();
+	const T2*& pData2=image2.data();
+	const T3*& pData3=image3.data();
+
+	for(int i=0;i<nElements;i++)
+		pData[i]=pData1[i]*pData2[i]*pData3[i];
+}
+
+template <class T>
+template <class T1,class T2>
+void Image<T>::Multiply(const Image<T1>& image1,const Image<T2>& image2)
+{
+	if(image1.matchDimension(image2)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Multiply()!"<<endl;
+		return;
+	}
+	if(matchDimension(image1)==false)
+		allocate(image1);
+
+	const T1*& pData1=image1.data();
+	const T2*& pData2=image2.data();
+
+	for(int i=0;i<nElements;i++)
+		pData[i]=pData1[i]*pData2[i];
+}
+
+template <class T>
+template <class T1>
+void Image<T>::Multiplywith(const Image<T1> &image1)
+{
+	if(matchDimension(image1)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Multiplywith()!"<<endl;
+		return;
+	}
+	const T1*& pData1=image1.data();
+	for(int i=0;i<nElements;i++)
+		pData[i]*=pData1[i];
+}
+
+template <class T>
+void Image<T>::Multiplywith(double value)
+{
+	for(int i=0;i<nElements;i++)
+		pData[i]*=value;
+}
+
+//------------------------------------------------------------------------------------------
+// function to add image2 to image1 to the current image
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1,class T2>
+void Image<T>::Add(const Image<T1>& image1,const Image<T2>& image2)
+{
+	if(image1.matchDimension(image2)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Add()!"<<endl;
+		return;
+	}
+	if(matchDimension(image1)==false)
+		allocate(image1);
+
+	const T1*& pData1=image1.data();
+	const T2*& pData2=image2.data();
+	for(int i=0;i<nElements;i++)
+		pData[i]=pData1[i]+pData2[i];	
+}
+
+template <class T>
+template <class T1,class T2>
+void Image<T>::Add(const Image<T1>& image1,const Image<T2>& image2,double ratio)
+{
+	if(image1.matchDimension(image2)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Add()!"<<endl;
+		return;
+	}
+	if(matchDimension(image1)==false)
+		allocate(image1);
+
+	const T1*& pData1=image1.data();
+	const T2*& pData2=image2.data();
+	for(int i=0;i<nElements;i++)
+		pData[i]=pData1[i]+pData2[i]*ratio;	
+}
+
+template <class T>
+template <class T1>
+void Image<T>::Add(const Image<T1>& image1,const double ratio)
+{
+	if(matchDimension(image1)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Add()!"<<endl;
+		return;
+	}
+	const T1*& pData1=image1.data();
+	for(int i=0;i<nElements;i++)
+		pData[i]+=pData1[i]*ratio;	
+}
+
+template <class T>
+template <class T1>
+void Image<T>::Add(const Image<T1>& image1)
+{
+	if(matchDimension(image1)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Add()!"<<endl;
+		return;
+	}
+	const T1*& pData1=image1.data();
+	for(int i=0;i<nElements;i++)
+		pData[i]+=pData1[i];	
+}
+
+
+template <class T>
+void Image<T>::Add(const T value)
+{
+	for(int i=0;i<nElements;i++)
+		pData[i]+=value;
+}
+
+//------------------------------------------------------------------------------------------
+// function to subtract image2 from image1
+//------------------------------------------------------------------------------------------
+template <class T>
+template <class T1,class T2>
+void Image<T>::Subtract(const Image<T1> &image1, const Image<T2> &image2)
+{
+	if(image1.matchDimension(image2)==false)
+	{
+		cout<<"Error in image dimensions--function Image<T>::Add()!"<<endl;
+		return;
+	}
+	if(matchDimension(image1)==false)
+		allocate(image1);
+
+	const T1*& pData1=image1.data();
+	const T2*& pData2=image2.data();
+	for(int i=0;i<nElements;i++)
+		pData[i]=pData1[i]-pData2[i];
+}
+
+//------------------------------------------------------------------------------------------
+// normalize an image
+//------------------------------------------------------------------------------------------
+template <class T>
+void Image<T>::normalize(Image<T>& image)
+{
+	if(image.width()!=imWidth || image.height()!=imHeight || image.nchannels()!=nChannels)
+		image.allocate(imWidth,imHeight,nChannels);
+	T Max,Min;
+	Max=Min=pData[0];
+	for(int i=0;i<nElements;i++)
+	{
+		Max=qMax(Max,pData[i]);
+		Min=qMin(Min,pData[i]);
+	}
+	if(Max==Min)
+		return;
+	double ratio=1/(Max-Min);
+	if(IsFloat()==false)
+		ratio*=255;
+	T* data=image.data();
+	for(int i=0;i<nElements;i++)
+		data[i]=(double)(pData[i]-Min)*ratio;
+}
+
+template <class T>
+double Image<T>::norm2() const
+{
+	double result=0;
+	for(int i=0;i<nElements;i++)
+		result+=pData[i]*pData[i];
+	return result;
+}
+
+template <class T>
+template <class T1>
+double Image<T>::innerproduct(Image<T1> &image) const
+{
+	double result=0;
+	const T1* pData1=image.data();
+	for(int i=0;i<nElements;i++)
+		result+=pData[i]*pData1[i];
+	return result;
+}
+
+#ifndef _MATLAB
+template <class T>
+bool Image<T>::writeImage(QFile &file) const
+{
+	file.write((char *)&imWidth,sizeof(int));
+	file.write((char *)&imHeight,sizeof(int));
+	file.write((char *)&nChannels,sizeof(int));
+	file.write((char *)&IsDerivativeImage,sizeof(bool));
+	if(file.write((char *)pData,sizeof(T)*nElements)!=sizeof(T)*nElements)
+		return false;
+	return true;
+}
+
+template <class T>
+bool Image<T>::readImage(QFile& file)
+{
+	clear();
+	file.read((char *)&imWidth,sizeof(int));
+	file.read((char *)&imHeight,sizeof(int));
+	file.read((char *)&nChannels,sizeof(int));
+	file.read((char *)&IsDerivativeImage,sizeof(bool));
+	if(imWidth<0 ||imWidth>100000 || imHeight<0 || imHeight>100000 || nChannels<0 || nChannels>10000)
+		return false;
+	allocate(imWidth,imHeight,nChannels);
+	if(file.read((char *)pData,sizeof(T)*nElements)!=sizeof(T)*nElements)
+		return false;
+	return true;
+}
+
+template <class T>
+bool Image<T>::writeImage(const QString &filename) const
+{
+	QFile file(filename);
+	if(file.open(QIODevice::WriteOnly)==false)
+		return false;
+	if(!writeImage(file))
+		return false;
+	return true;
+}
+
+template <class T>
+bool Image<T>::readImage(const QString &filename)
+{
+	QFile file(filename);
+	if(file.open(QIODevice::ReadOnly)==false)
+		return false;
+	if(!readImage(file))
+		return false;
+	return true;
+}
+#endif
+
+
+template <class T>
+template <class T1>
+void Image<T>::BilateralFiltering(Image<T1>& other,int fsize,double filter_sigma,double range_sigma)
+{
+	double *pBuffer;
+	Image<T1> result(other);
+	pBuffer=new double[other.nchannels()];
+	for(int i=0;i<imHeight;i++)
+		for(int j=0;j<imWidth;j++)
+		{
+			double totalWeight=0;
+			for(int k=0;k<other.nchannels();k++)
+				pBuffer[k]=0;
+			for(int ii=-fsize;ii<=fsize;ii++)
+				for(int jj=-fsize;jj<=fsize;jj++)
+				{
+					int x=j+jj;
+					int y=i+ii;
+					if(x<0 || x>=imWidth || y<0 || y>=imHeight)
+						continue;
+
+					// compute weight
+					int offset=(y*imWidth+x)*nChannels;
+					double temp=0;
+					for(int k=0;k<nChannels;k++)
+					{
+						double diff=pData[offset+k]-pData[(i*imWidth+j)*nChannels+k];
+						temp+=diff*diff;
+					}
+					double weight=exp(-temp/(2*range_sigma*range_sigma));
+					weight*=exp(-(double)(ii*ii+jj*jj)/(2*filter_sigma*filter_sigma));
+					totalWeight+=weight;
+					for(int k=0;k<other.nchannels();k++)
+						pBuffer[k]+=other.data()[(y*imWidth+x)*other.nchannels()+k]*weight;
+				}
+			for(int k=0;k<other.nchannels();k++)
+				result.data()[(i*imWidth+j)*other.nchannels()]=pBuffer[k]/totalWeight;
+		}
+	other.copyData(result);
+	delete pBuffer;
+}
+
+
+#ifdef _MATLAB
+
+template <class T>
+template <class T1>
+void Image<T>::LoadMatlabImageCore(const mxArray *image,bool IsImageScaleCovnersion)
+{
+	int nDim = mxGetNumberOfDimensions(image);
+	const mwSize* imDim = mxGetDimensions(image);
+	if(nDim==2)
+		allocate(imDim[1],imDim[0]);
+	else if(nDim==3)
+		allocate(imDim[1],imDim[0],imDim[2]);
+	else
+		mexErrMsgTxt("The image doesn't have the appropriate dimension!");
+	T1* pMatlabPlane=(T1*)mxGetData(image);
+	bool IsMatlabFloat;
+	if(typeid(T1)==typeid(float) || typeid(T1)==typeid(double) || typeid(T1)==typeid(long double))
+		IsMatlabFloat=true;
+	else
+		IsMatlabFloat=false;
+	bool isfloat=IsFloat();
+	if(isfloat==IsMatlabFloat || IsImageScaleCovnersion==false)
+	{
+		ConvertFromMatlab<T1>(pMatlabPlane,imWidth,imHeight,nChannels);
+		return;
+	}
+	int offset=0;
+	if(isfloat==true)
+		for(int i=0;i<imHeight;i++)
+			for(int j=0;j<imWidth;j++)
+				for(int k=0;k<nChannels;k++)
+					pData[offset++]=(double)pMatlabPlane[k*nPixels+j*imHeight+i]/255;
+	else
+		for(int i=0;i<imHeight;i++)
+			for(int j=0;j<imWidth;j++)
+				for(int k=0;k<nChannels;k++)
+					pData[offset++]=(double)pMatlabPlane[k*nPixels+j*imHeight+i]*255;
+}
+
+template <class T>
+bool Image<T>::LoadMatlabImage(const mxArray* matrix,bool IsImageScaleCovnersion)
+{
+	if(mxIsClass(matrix,"uint8"))
+	{
+		LoadMatlabImageCore<unsigned char>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	if(mxIsClass(matrix,"int8"))
+	{
+		LoadMatlabImageCore<char>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	if(mxIsClass(matrix,"int32"))
+	{
+		LoadMatlabImageCore<int>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	if(mxIsClass(matrix,"uint32"))
+	{
+		LoadMatlabImageCore<unsigned int>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	if(mxIsClass(matrix,"int16"))
+	{
+		LoadMatlabImageCore<short int>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	if(mxIsClass(matrix,"uint16"))
+	{
+		LoadMatlabImageCore<unsigned short int>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	if(mxIsClass(matrix,"single"))
+	{
+		LoadMatlabImageCore<float>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	if(mxIsClass(matrix,"double"))
+	{
+		LoadMatlabImageCore<double>(matrix,IsImageScaleCovnersion);
+		return true;
+	}
+	mexErrMsgTxt("Unknown type of the image!");
+	return false;
+}
+
+
+template <class T>
+template <class T1>
+void Image<T>::ConvertFromMatlab(const T1 *pMatlabPlane, int _width, int _height, int _nchannels)
+{
+	if(imWidth!=_width || imHeight!=_height || nChannels!=_nchannels)
+		allocate(_width,_height,_nchannels);
+	int offset=0;
+	for(int i=0;i<imHeight;i++)
+		for(int j=0;j<imWidth;j++)
+			for(int k=0;k<nChannels;k++)
+				pData[offset++]=pMatlabPlane[k*nPixels+j*imHeight+i];
+}
+
+// convert image data to matlab matrix
+template <class T>
+template <class T1>
+void Image<T>::ConvertToMatlab(T1 *pMatlabPlane)
+{
+	int offset=0;
+	for(int i=0;i<imHeight;i++)
+		for(int j=0;j<imWidth;j++)
+			for(int k=0;k<nChannels;k++)
+				pMatlabPlane[k*nPixels+j*imHeight+i]=pData[offset++];
+}
+
+template <class T>
+void Image<T>::OutputToMatlab(mxArray *&matrix)
+{
+	mwSize dims[3];
+	dims[0]=imHeight;
+	dims[1]=imWidth;
+	dims[2]=nChannels;
+	if(nChannels==1)
+		matrix=mxCreateNumericArray(2, dims,mxDOUBLE_CLASS, mxREAL);
+	else
+		matrix=mxCreateNumericArray(3, dims,mxDOUBLE_CLASS, mxREAL);
+	ConvertToMatlab<double>((double*)mxGetData(matrix));
+}
+
+#endif
+
+
+#endif

UVDoc_official/eval/eval_code/SIFTflow/mexDiscreteFlow/ImageIO.h

@@ -0,0 +1,200 @@
+#ifndef _ImageIO_h
+#define _ImageIO_h
+
+#include <QVector>
+#include <QImage>
+#include <QString>
+#include "math.h"
+//-----------------------------------------------------------------------------------------
+// this class is a wrapper to use QImage to load image into image planes
+//-----------------------------------------------------------------------------------------
+
+class ImageIO
+{
+public:
+	enum ImageType{standard, derivative, normalized};
+	ImageIO(void);
+	~ImageIO(void);
+public:
+	template <class T>
+	static void loadImage(const QImage& image,T*& pImagePlane,int& width,int& height,int& nchannels);
+	template <class T>
+	static bool loadImage(const QString& filename,T*& pImagePlane,int& width,int& height,int& nchannels);
+
+	template <class T>
+	static unsigned char convertPixel(const T& value,bool IsFloat,ImageType type,T& _Max,T& _Min);
+
+	template <class T>
+	static bool writeImage(const QString& filename, const T*& pImagePlane,int width,int height,int nchannels,ImageType type=standard,int quality=-1);
+
+	template <class T>
+	static bool writeImage(const QString& filename,const T* pImagePlane,int width,int height,int nchannels,T min, T max,int quality=-1);
+
+};
+
+template <class T>
+void ImageIO::loadImage(const QImage& image, T*& pImagePlane,int& width,int& height,int& nchannels)
+{
+	// get the image information
+	width=image.width();
+	height=image.height();
+	nchannels=3;
+	pImagePlane=new T[width*height*nchannels];
+
+	// check whether the type is float point
+	bool IsFloat=false;
+	if(typeid(T)==typeid(double) || typeid(T)==typeid(float) || typeid(T)==typeid(long double))
+		IsFloat=true;
+
+	const unsigned char* plinebuffer;
+	for(int i=0;i<height;i++)
+	{
+		plinebuffer=image.scanLine(i);
+		for(int j=0;j<width;j++)
+		{
+			if(IsFloat)
+			{
+				pImagePlane[(i*width+j)*3]=(T)plinebuffer[j*4]/255;
+				pImagePlane[(i*width+j)*3+1]=(T)plinebuffer[j*4+1]/255;
+				pImagePlane[(i*width+j)*3+2]=(T)plinebuffer[j*4+2]/255;
+			}
+			else
+			{
+				pImagePlane[(i*width+j)*3]=plinebuffer[j*4];
+				pImagePlane[(i*width+j)*3+1]=plinebuffer[j*4+1];
+				pImagePlane[(i*width+j)*3+2]=plinebuffer[j*4+2];
+			}
+		}
+	}
+}
+
+template <class T>
+bool ImageIO::loadImage(const QString&filename, T*& pImagePlane,int& width,int& height,int& nchannels)
+{
+	QImage image;
+	if(image.load(filename)==false)
+		return false;
+	if(image.format()!=QImage::Format_RGB32)
+	{
+		QImage temp=image.convertToFormat(QImage::Format_RGB32);
+		image=temp;
+	}
+	loadImage(image,pImagePlane,width,height,nchannels);
+	return true;
+}
+
+template <class T>
+bool ImageIO::writeImage(const QString& filename, const T*& pImagePlane,int width,int height,int nchannels,ImageType type,int quality)
+{
+	int nPixels=width*height,nElements;
+	nElements=nPixels*nchannels;
+	unsigned char* pTempBuffer;
+	pTempBuffer=new unsigned char[nPixels*4];
+	memset(pTempBuffer,0,nPixels*4);
+
+	// check whether the type is float point
+	bool IsFloat=false;
+	if(typeid(T)==typeid(double) || typeid(T)==typeid(float) || typeid(T)==typeid(long double))
+		IsFloat=true;
+
+	T _Max=0,_Min=0;
+	switch(type){
+		case standard:
+			break;
+		case derivative:
+			_Max=0;
+			for(int i=0;i<nPixels;i++)
+			{
+				if(IsFloat)
+					_Max=__max(_Max,fabs((double)pImagePlane[i]));
+				else
+					_Max=__max(_Max,abs(pImagePlane[i]));
+			}
+			break;
+		case normalized:
+			_Min=_Max=pImagePlane[0];
+			for(int i=1;i<nElements;i++)
+			{
+				_Min=__min(_Min,pImagePlane[i]);
+				_Max=__max(_Max,pImagePlane[i]);
+			}
+			break;
+	}
+
+	for(int i=0;i<nPixels;i++)
+	{
+		if(nchannels>=3)
+		{
+			pTempBuffer[i*4]=convertPixel(pImagePlane[i*nchannels],IsFloat,type,_Max,_Min);
+			pTempBuffer[i*4+1]=convertPixel(pImagePlane[i*nchannels+1],IsFloat,type,_Max,_Min);
+			pTempBuffer[i*4+2]=convertPixel(pImagePlane[i*nchannels+2],IsFloat,type,_Max,_Min);
+		}
+		else 
+			for (int j=0;j<3;j++)
+				pTempBuffer[i*4+j]=convertPixel(pImagePlane[i*nchannels],IsFloat,type,_Max,_Min);
+		pTempBuffer[i*4+3]=255;
+	}
+	QImage *pQImage=new QImage(pTempBuffer,width,height,QImage::Format_RGB32);
+	bool result= pQImage->save(filename,0,quality);
+	delete pQImage;
+	delete pTempBuffer;
+	return result;
+}
+
+template <class T>
+bool ImageIO::writeImage(const QString& filename, const T* pImagePlane,int width,int height,int nchannels,T min,T max,int quality)
+{
+	int nPixels=width*height,nElements;
+	nElements=nPixels*nchannels;
+	unsigned char* pTempBuffer;
+	pTempBuffer=new unsigned char[nPixels*4];
+	memset(pTempBuffer,0,nPixels*4);
+
+	// check whether the type is float point
+	bool IsFloat=false;
+	if(typeid(T)==typeid(double) || typeid(T)==typeid(float) || typeid(T)==typeid(long double))
+		IsFloat=true;
+
+	T _Max=max,_Min=min;
+
+	for(int i=0;i<nPixels;i++)
+	{
+		if(nchannels>=3)
+		{
+			pTempBuffer[i*4]=convertPixel(pImagePlane[i*nchannels],IsFloat,normalized,_Max,_Min);
+			pTempBuffer[i*4+1]=convertPixel(pImagePlane[i*nchannels+1],IsFloat,normalized,_Max,_Min);
+			pTempBuffer[i*4+2]=convertPixel(pImagePlane[i*nchannels+2],IsFloat,normalized,_Max,_Min);
+		}
+		else 
+			for (int j=0;j<3;j++)
+				pTempBuffer[i*4+j]=convertPixel(pImagePlane[i*nchannels],IsFloat,normalized,_Max,_Min);
+		pTempBuffer[i*4+3]=255;
+	}
+	QImage *pQImage=new QImage(pTempBuffer,width,height,QImage::Format_RGB32);
+	bool result= pQImage->save(filename,0,quality);
+	delete pQImage;
+	delete pTempBuffer;
+	return result;
+}
+
+template <class T>
+unsigned char ImageIO::convertPixel(const T& value,bool IsFloat,ImageType type,T& _Max,T& _Min)
+{
+	switch(type){
+		case standard:
+			if(IsFloat)
+				return __max(__min(value*255,255),0);
+			else
+				return __max(__min(value,255),0);
+			break;
+		case derivative:
+			return (double)((double)value/_Max+1)/2*255;
+			break;
+		case normalized:
+			return (double)(value-_Min)/(_Max-_Min)*255;
+			break;
+	}
+	return 0;
+}
+
+#endif

UVDoc_official/eval/eval_code/SIFTflow/mexDiscreteFlow/ImageProcessing.h

@@ -0,0 +1,387 @@
+#ifndef _ImageProcessing_h
+#define _ImageProcessing_h
+
+#include "math.h"
+#include "stdio.h"
+#include "stdlib.h"
+#include <typeinfo>
+
+//----------------------------------------------------------------------------------
+// class to handle basic image processing functions
+// this is a collection of template functions. These template functions are
+// used in other image classes such as BiImage, IntImage and FImage 
+//----------------------------------------------------------------------------------
+
+class ImageProcessing
+{
+public:
+	ImageProcessing(void);
+	~ImageProcessing(void);
+public:
+	// basic functions
+	template <class T>
+	static inline T EnforceRange(const T& x,const int& MaxValue) {return __min(__max(x,0),MaxValue-1);};
+
+	//---------------------------------------------------------------------------------
+	// function to interpolate the image plane
+	//---------------------------------------------------------------------------------
+	template <class T1,class T2> 
+	static inline void BilinearInterpolate(const T1* pImage,int width,int height,int nChannels,double x,double y,T2* result);
+
+	template <class T1>
+	static inline T1 BilinearInterpolate(const T1* pImage,int width,int height,double x,double y);
+
+	template <class T1,class T2>
+	static void ResizeImage(const T1* pSrcImage,T2* pDstImage,int SrcWidth,int SrcHeight,int nChannels,double Ratio);
+
+	template <class T1,class T2>
+	static void ResizeImage(const T1* pSrcImage,T2* pDstImage,int SrcWidth,int SrcHeight,int nChannels,int DstWidth,int DstHeight);
+
+	//---------------------------------------------------------------------------------
+	// functions for 1D filtering
+	//---------------------------------------------------------------------------------
+	template <class T1,class T2>
+	static void hfiltering(const T1* pSrcImage,T2* pDstImage,int width,int height,int nChannels,double* pfilter1D,int fsize);
+
+	template <class T1,class T2>
+	static void vfiltering(const T1* pSrcImage,T2* pDstImage,int width,int height,int nChannels,double* pfilter1D,int fsize);
+
+	//---------------------------------------------------------------------------------
+	// functions for 2D filtering
+	//---------------------------------------------------------------------------------
+	template <class T1,class T2>
+	static void filtering(const T1* pSrcImage,T2* pDstImage,int width,int height,int nChannels,double* pfilter2D,int fsize);
+
+	template <class T1,class T2>
+	static void Laplacian(const T1* pSrcImage,T2* pDstImage,int width,int height,int nChannels);
+
+	//---------------------------------------------------------------------------------
+	// functions for sample a patch from the image
+	//---------------------------------------------------------------------------------
+	template <class T1,class T2>
+	static void getPatch(const T1* pSrcImgae,T2* pPatch,int width,int height,int nChannels,double x,double y,int wsize);
+	
+	//---------------------------------------------------------------------------------
+	// function to warp image
+	//---------------------------------------------------------------------------------
+	template <class T1,class T2>
+	static void warpImage(T1* pWarpIm2,const T1* pIm1,const T1* pIm2,const T2* pVx,const T2* pVy,int width,int height,int nChannels);
+
+	//---------------------------------------------------------------------------------
+	// function to crop an image
+	//---------------------------------------------------------------------------------
+	template <class T1,class T2>
+	static void cropImage(const T1* pSrcImage,int SrcWidth,int SrcHeight,int nChannels,T2* pDstImage,int Left,int Top,int DstWidth,int DstHeight);
+	//---------------------------------------------------------------------------------
+
+	//---------------------------------------------------------------------------------
+	// function to generate a 2D Gaussian 
+	//---------------------------------------------------------------------------------
+	template <class T>
+	static void generate2DGaussian(T*& pImage,int wsize,double sigma=-1);
+};
+
+//--------------------------------------------------------------------------------------------------
+// function to interplate multi-channel image plane for (x,y)
+// --------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+inline void ImageProcessing::BilinearInterpolate(const T1* pImage,int width,int height,int nChannels,double x,double y,T2* result)
+{
+	int xx,yy,m,n,u,v,l,offset;
+	xx=x;
+	yy=y;
+	double dx,dy,s;
+	dx=__max(__min(x-xx,1),0);
+	dy=__max(__min(y-yy,1),0);
+
+	memset(result,0,sizeof(T2)*nChannels);
+
+	for(m=0;m<=1;m++)
+		for(n=0;n<=1;n++)
+		{
+			u=EnforceRange(xx+m,width);
+			v=EnforceRange(yy+n,height);
+			offset=(v*width+u)*nChannels;
+			s=fabs(1-m-dx)*fabs(1-n-dy);
+			for(l=0;l<nChannels;l++)
+				result[l]+=pImage[offset+l]*s;
+		}
+}
+
+template <class T1>
+inline T1 ImageProcessing::BilinearInterpolate(const T1* pImage,int width,int height,double x,double y)
+{
+	int xx,yy,m,n,u,v,l,offset;
+	xx=x;
+	yy=y;
+	double dx,dy,s;
+	dx=__max(__min(x-xx,1),0);
+	dy=__max(__min(y-yy,1),0);
+
+	T1 result=0;
+	for(m=0;m<=1;m++)
+		for(n=0;n<=1;n++)
+		{
+			u=EnforceRange(xx+m,width);
+			v=EnforceRange(yy+n,height);
+			offset=v*width+u;
+			s=fabs(1-m-dx)*fabs(1-n-dy);
+			result+=pImage[offset]*s;
+		}
+	return result;
+}
+//------------------------------------------------------------------------------------------------------------
+// this is the most general function for reszing an image with a varying nChannels
+// bilinear interpolation is used for now. It might be replaced by other (bicubic) interpolation methods 
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::ResizeImage(const T1* pSrcImage,T2* pDstImage,int SrcWidth,int SrcHeight,int nChannels,double Ratio)
+{
+	int DstWidth,DstHeight;
+	DstWidth=(double)SrcWidth*Ratio;
+	DstHeight=(double)SrcHeight*Ratio;
+	memset(pDstImage,sizeof(T2)*DstWidth*DstHeight*nChannels,0);
+	
+	double x,y;
+
+	for(int i=0;i<DstHeight;i++)
+		for(int j=0;j<DstWidth;j++)
+		{
+			x=(double)(j+1)/Ratio-1;
+			y=(double)(i+1)/Ratio-1;
+
+			// bilinear interpolation
+			BilinearInterpolate(pSrcImage,SrcWidth,SrcHeight,nChannels,x,y,pDstImage+(i*DstWidth+j)*nChannels);
+		}
+}
+
+template <class T1,class T2>
+void ImageProcessing::ResizeImage(const T1 *pSrcImage, T2 *pDstImage, int SrcWidth, int SrcHeight, int nChannels, int DstWidth, int DstHeight)
+{
+	double xRatio=(double)DstWidth/SrcWidth;
+	double yRatio=(double)DstHeight/SrcHeight;
+	memset(pDstImage,sizeof(T2)*DstWidth*DstHeight*nChannels,0);
+
+	double x,y;
+
+	for(int i=0;i<DstHeight;i++)
+		for(int j=0;j<DstWidth;j++)
+		{
+			x=(double)(j+1)/xRatio-1;
+			y=(double)(i+1)/yRatio-1;
+
+			// bilinear interpolation
+			BilinearInterpolate(pSrcImage,SrcWidth,SrcHeight,nChannels,x,y,pDstImage+(i*DstWidth+j)*nChannels);
+		}
+}
+
+//------------------------------------------------------------------------------------------------------------
+//  horizontal direction filtering
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::hfiltering(const T1* pSrcImage,T2* pDstImage,int width,int height,int nChannels,double* pfilter1D,int fsize)
+{
+	memset(pDstImage,0,sizeof(T2)*width*height*nChannels);
+	T2* pBuffer;
+	double w;
+	int i,j,l,k,offset,jj;
+	for(i=0;i<height;i++)
+		for(j=0;j<width;j++)
+		{
+			offset=i*width*nChannels;
+			pBuffer=pDstImage+offset+j*nChannels;
+			for(l=-fsize;l<=fsize;l++)
+			{
+				w=pfilter1D[l+fsize];
+				jj=EnforceRange(j+l,width);
+				for(k=0;k<nChannels;k++)
+					pBuffer[k]+=pSrcImage[offset+jj*nChannels+k]*w;
+			}
+		}
+}
+
+//------------------------------------------------------------------------------------------------------------
+// fast filtering algorithm for laplacian
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::Laplacian(const T1 *pSrcImage, T2 *pDstImage, int width, int height, int nChannels)
+{
+	int LineWidth=width*nChannels;
+	int nElements=width*height*nChannels;
+	// first treat the corners
+	for(int k=0;k<nChannels;k++)
+	{
+		pDstImage[k]=pSrcImage[k]*2-pSrcImage[nChannels+k]-pSrcImage[LineWidth+k];
+		pDstImage[LineWidth-nChannels+k]=pSrcImage[LineWidth-nChannels+k]*2-pSrcImage[LineWidth-2*nChannels+k]-pSrcImage[2*LineWidth-nChannels+k];
+		pDstImage[nElements-LineWidth+k]=pSrcImage[nElements-LineWidth+k]*2-pSrcImage[nElements-LineWidth+nChannels+k]-pSrcImage[nElements-2*LineWidth+k];
+		pDstImage[nElements-nChannels+k]=pSrcImage[nElements-nChannels+k]*2-pSrcImage[nElements-2*nChannels+k]-pSrcImage[nElements-LineWidth-nChannels+k];
+	}
+	// then treat the borders
+	for(int i=1;i<width-1;i++)
+		for(int k=0;k<nChannels;k++)
+		{
+			pDstImage[i*nChannels+k]=pSrcImage[i*nChannels+k]*3-pSrcImage[(i-1)*nChannels+k]-pSrcImage[(i+1)*nChannels+k]-pSrcImage[i*nChannels+LineWidth+k];
+			pDstImage[nElements-LineWidth+i*nChannels+k]=pSrcImage[nElements-LineWidth+i*nChannels+k]*3-pSrcImage[nElements-LineWidth+(i-1)*nChannels+k]-pSrcImage[nElements-LineWidth+(i+1)*nChannels+k]-pSrcImage[nElements-2*LineWidth+i*nChannels+k];
+		}
+	for(int i=1;i<height-1;i++)
+		for(int k=0;k<nChannels;k++)
+		{
+			pDstImage[i*LineWidth+k]=pSrcImage[i*LineWidth+k]*3-pSrcImage[i*LineWidth+nChannels+k]-pSrcImage[(i-1)*LineWidth+k]-pSrcImage[(i+1)*LineWidth+k];
+			pDstImage[(i+1)*LineWidth-nChannels+k]=pSrcImage[(i+1)*LineWidth-nChannels+k]*3-pSrcImage[(i+1)*LineWidth-2*nChannels+k]-pSrcImage[i*LineWidth-nChannels+k]-pSrcImage[(i+2)*LineWidth-nChannels+k];
+		}
+	// now the interior
+	for(int i=1;i<height-1;i++)
+		for(int j=1;j<width-1;j++)
+		{
+			int offset=(i*width+j)*nChannels;
+			for(int k=0;k<nChannels;k++)
+				pDstImage[offset+k]=pSrcImage[offset+k]*4-pSrcImage[offset+nChannels+k]-pSrcImage[offset-nChannels+k]-pSrcImage[offset-LineWidth+k]-pSrcImage[offset+LineWidth+k];
+		}
+}
+
+
+//------------------------------------------------------------------------------------------------------------
+// vertical direction filtering
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::vfiltering(const T1* pSrcImage,T2* pDstImage,int width,int height,int nChannels,double* pfilter1D,int fsize)
+{
+	memset(pDstImage,0,sizeof(T2)*width*height*nChannels);
+	T2* pBuffer;
+	double w;
+	int i,j,l,k,offset,ii;
+	for(i=0;i<height;i++)
+		for(j=0;j<width;j++)
+		{
+			pBuffer=pDstImage+(i*width+j)*nChannels;
+			for(l=-fsize;l<=fsize;l++)
+			{
+				w=pfilter1D[l+fsize];
+				ii=EnforceRange(i+l,height);
+				for(k=0;k<nChannels;k++)
+					pBuffer[k]+=pSrcImage[(ii*width+j)*nChannels+k]*w;
+			}
+		}
+}
+
+//------------------------------------------------------------------------------------------------------------
+// 2d filtering
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::filtering(const T1* pSrcImage,T2* pDstImage,int width,int height,int nChannels,double* pfilter2D,int fsize)
+{
+	double w;
+	int i,j,u,v,k,ii,jj,wsize,offset;
+	wsize=fsize*2+1;
+	double* pBuffer=new double[nChannels];
+	for(i=0;i<height;i++)
+		for(j=0;j<width;j++)
+		{
+			for(k=0;k<nChannels;k++)
+				pBuffer[k]=0;
+			for(u=-fsize;u<=fsize;u++)
+				for(v=-fsize;v<=fsize;v++)
+				{
+					w=pfilter2D[(u+fsize)*wsize+v+fsize];
+					ii=EnforceRange(i+u,height);
+					jj=EnforceRange(j+v,width);
+					offset=(ii*width+jj)*nChannels;
+					for(k=0;k<nChannels;k++)
+						pBuffer[k]+=pSrcImage[offset+k]*w;
+				}
+			offset=(i*width+j)*nChannels;
+			for(k=0;k<nChannels;k++)
+				pDstImage[offset+k]=pBuffer[k];
+		}
+	delete pBuffer;
+}
+
+//------------------------------------------------------------------------------------------------------------
+// function to sample a patch from the source image
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::getPatch(const T1* pSrcImage,T2* pPatch,int width,int height,int nChannels,double x0,double y0,int wsize)
+{
+	// suppose pPatch has been allocated and cleared before calling the function
+	int wlength=wsize*2+1;
+	double x,y;
+	for(int i=-wsize;i<=wsize;i++)
+		for(int j=-wsize;j<=wsize;j++)
+		{
+			y=y0+i;
+			x=x0+j;
+			if(x<0 || x>width-1 || y<0 || y>height-1)
+				continue;
+			BilinearInterpolate(pSrcImage,width,height,nChannels,x,y,pPatch+((i+wsize)*wlength+j+wsize)*nChannels);
+		}
+}
+
+//------------------------------------------------------------------------------------------------------------
+// function to warp an image with respect to flow field
+// pWarpIm2 has to be allocated before hands
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::warpImage(T1 *pWarpIm2, const T1 *pIm1, const T1 *pIm2, const T2 *pVx, const T2 *pVy, int width, int height, int nChannels)
+{
+	for(int i=0;i<height;i++)
+		for(int j=0;j<width;j++)
+		{
+			int offset=i*width+j;
+			double x,y;
+			y=i+pVy[offset];
+			x=j+pVx[offset];
+			offset*=nChannels;
+			if(x<0 || x>width-1 || y<0 || y>height-1)
+			{
+				for(int k=0;k<nChannels;k++)
+					pWarpIm2[offset+k]=pIm1[offset+k];
+				continue;
+			}
+			BilinearInterpolate(pIm2,width,height,nChannels,x,y,pWarpIm2+offset);
+		}
+}
+
+//------------------------------------------------------------------------------------------------------------
+// function to crop an image from the source
+// assume that pDstImage has been allocated
+// also Left and Top must be valid, DstWidth and DstHeight should ensure that the image lies
+// inside the image boundary
+//------------------------------------------------------------------------------------------------------------
+template <class T1,class T2>
+void ImageProcessing::cropImage(const T1 *pSrcImage, int SrcWidth, int SrcHeight, int nChannels, T2 *pDstImage, int Left, int Top, int DstWidth, int DstHeight)
+{
+	if(typeid(T1)==typeid(T2))
+	{
+		for(int i=0;i<DstHeight;i++)
+			memcpy(pDstImage+i*DstWidth*nChannels,pSrcImage+((i+Top)*SrcWidth+Left)*nChannels,sizeof(T1)*DstWidth*nChannels);
+		return;
+	}
+	int offsetSrc,offsetDst;
+	for(int i=0;i<DstHeight;i++)
+		for(int j=0;j<DstWidth;j++)
+		{
+			offsetSrc=((i+Top)*SrcWidth+Left+j)*nChannels;
+			offsetDst=(i*DstWidth+j)*nChannels;
+			for(int k=0;k<nChannels;k++)
+				pDstImage[offsetDst+k]=pSrcImage[offsetSrc+k];
+		}
+}
+
+//------------------------------------------------------------------------------------------------------------
+// function to generate a 2D Gaussian image
+// pImage must be allocated before calling the function
+//------------------------------------------------------------------------------------------------------------
+template <class T>
+void ImageProcessing::generate2DGaussian(T*& pImage, int wsize, double sigma)
+{
+	if(sigma==-1)
+		sigma=wsize;
+	double alpha=1/(2*sigma*sigma);
+	int winlength=wsize*2+1;
+	if(pImage==NULL)
+		pImage=new T[winlength*winlength];
+	for(int i=-wsize;i<=wsize;i++)
+		for(int j=-wsize;j<=wsize;j++)
+			pImage[(i+wsize)*winlength+j+wsize]=exp(-(double)(i*i+j*j)*alpha);
+}
+#endif

UVDoc_official/eval/eval_code/SIFTflow/mexDiscreteFlow/Stochastic.cpp

@@ -0,0 +1,107 @@
+#include "Stochastic.h"
+#include "time.h"
+#include "stdlib.h"
+#include "stdio.h"
+
+CStochastic::CStochastic(void)
+{
+}
+
+CStochastic::~CStochastic(void)
+{
+}
+
+void CStochastic::ConvertInt2String(int x,char* string,int BitNumber)
+{
+	int i,Base=1;
+	for(i=1;i<BitNumber;i++)
+		Base*=10;
+	for(i=0;i<BitNumber;i++)
+	{
+		string[i]=x/Base+'0';
+		x%=Base;
+		Base/=10;
+	}
+	string[i]='\0';
+}
+
+double CStochastic::UniformSampling()
+{
+	return (double)rand()/(RAND_MAX+1);
+}
+
+int CStochastic::UniformSampling(int R)
+{
+	int Index=(double)UniformSampling()*R;
+	if(Index>R-1)
+		Index=R-1;
+	return Index;
+}
+
+double CStochastic::GaussianSampling()
+{
+	int i;
+	double result=0;
+	for (i=0;i<12;i++)
+		result+=UniformSampling();
+	result-=6;
+	return result;
+}
+
+
+double CStochastic::GetMean(double* signal,int length)
+{
+	double mean=0;
+	int i;
+	for(i=0;i<length;i++)
+		mean+=signal[i];
+	mean/=length;
+	return mean;
+}
+
+int CStochastic::Sampling(double* Density,int NumSamples)
+{
+	double RandNumber=UniformSampling();
+	int i;
+	double sum=0;
+	for(i=0;i<NumSamples;i++)
+	{
+		sum+=Density[i];
+		if(sum>=RandNumber)
+			return i;
+	}
+	return NumSamples-1;
+}
+
+void CStochastic::Generate1DGaussian(double* pGaussian,int size,double sigma)
+{
+	int i;
+	if(sigma==0)
+		sigma=size/2;
+	for(i=-size;i<=size;i++)
+		pGaussian[i+size]=exp(-(double)i*i/(2*sigma));
+}
+
+void CStochastic::Generate2DGaussian(double* pGaussian,int WinSize,double sigma)
+{
+	int i,j,WinLength=WinSize*2+1;
+	double Sigma;
+	if(sigma==0)
+		Sigma=WinSize;
+	else
+		Sigma=sigma;
+	Sigma*=Sigma;
+	for (i=-WinSize;i<=WinSize;i++)
+		for(j=-WinSize;j<=WinSize;j++)
+			pGaussian[(i+WinSize)*WinLength+j+WinSize]=exp(-(double)(i*i+j*j)/(2*Sigma));
+	Normalize(WinLength*WinLength,pGaussian);
+}
+
+double CStochastic::entropy(double* pDensity,int n)
+{
+	double result=0;
+	int i;
+	for(i=0;i<n;i++)
+		result-=log(__max(pDensity[i],1E-6))*pDensity[i];
+	return result;
+}

UVDoc_official/eval/eval_code/SIFTflow/mexDiscreteFlow/Stochastic.h

@@ -0,0 +1,410 @@
+#ifndef STOCHASTIC_H
+#define STOCHASTIC_H
+
+#include "math.h"
+#include "stdlib.h"
+#include "project.h"
+#include "memory.h"
+
+#define _Release_2DArray(X,i,length) for(i=0;i<length;i++) if(X[i]!=NULL) delete X[i]; delete []X
+
+#ifndef _abs(x)
+#define _abs(x) (x>=0)?x:-x
+#endif
+
+#ifndef PI
+#define PI 3.1415927
+#endif
+
+enum SortType{SortAscending,SortDescending};
+
+class CStochastic
+{
+public:
+	CStochastic(void);
+	~CStochastic(void);
+	static void ConvertInt2String(int x,char* string,int BitNumber=3);
+	static double UniformSampling();
+	static int UniformSampling(int R);
+	static double GaussianSampling();
+	template <class T> static void GetMeanVar(T* signal,int length,double* mean,double* var);
+	static int Sampling(double* Density,int NumSamples);
+	static double GetMean(double *signal,int length);
+	static void Generate1DGaussian(double* pGaussian,int size,double sigma=0);
+	static void Generate2DGaussian(double* pGaussian,int size,double sigma=0);
+	static double entropy(double* pDensity,int n);
+
+	template <class T> static T sum(int NumData,T* pData);
+	template <class T> static void Normalize(int NumData,T* pData);
+	template <class T> static T mean(int NumData, T* pData);
+	template <class T> static void sort(int number, T* pData,int *pIndex,SortType m_SortType=SortDescending);
+	template <class T> static T Min(int NumData, T* pData);
+	template <class T> static T Min(int NumData, T* pData1,T* pData2);
+	template <class T> static T Max(int NumData ,T* pData);
+	template <class T> static int FindMax(int NumData,T* pData);
+	template <class T1,class T2> static void ComputeVectorMean(int Dim,int NumData,T1* pData,T2* pMean,double* pWeight=NULL);
+	template <class T1,class T2> static void ComputeMeanCovariance(int Dim,int NumData,T1* pData,T2* pMean,T2* pCovarance,double* pWeight=NULL);
+	template <class T1,class T2> static double VectorSquareDistance(int Dim,T1* pVector1,T2* pVector2);
+	template <class T1> static void KMeanClustering(int Dim,int NumData,int NumClusters,T1* pData,int *pPartition,double** pClusterMean=NULL,int MaxIterationNum=10,int MinClusterSampleNumber=2);
+	template <class T> static double norm(T* X,int Dim);
+	template <class T1,class T2> static int FindClosestPoint(T1* pPointSet,int NumPoints,int nDim,T2* QueryPoint);
+	template <class T1,class T2> static void GaussianFiltering(T1* pSrcArray,T2* pDstArray,int NumPoints,int nChannels,int size,double sigma);
+};
+
+template <class T>
+void CStochastic::GetMeanVar(T* signal,int length,double* mean,double* var)
+{
+	double m_mean=0,m_var=0;
+
+	int i;
+	for (i=0;i<length;i++)
+		m_mean+=signal[i];
+	m_mean/=length;
+	for (i=0;i<length;i++)
+		m_var+=(signal[i]-m_mean)*(signal[i]-m_mean);
+	m_var/=length-1;
+	*mean=m_mean;
+	*var=m_var;
+}
+
+template <class T>
+T CStochastic::sum(int NumData, T* pData)
+{
+	T sum=0;
+	int i;
+	for(i=0;i<NumData;i++)
+		sum+=pData[i];
+	return sum;
+}
+
+template <class T>
+void CStochastic::Normalize(int NumData,T* pData)
+{
+	int i;
+	T Sum;
+	Sum=sum(NumData,pData);
+	for(i=0;i<NumData;i++)
+		pData[i]/=Sum;
+}
+
+template <class T>
+T CStochastic::mean(int NumData,T* pData)
+{
+	return sum(NumData,pData)/NumData;
+}
+
+////////////////////////////////////////////////////////////
+// sort data in descending order
+template <class T>
+void CStochastic::sort(int Number,T* pData,int *pIndex,SortType m_SortType)
+{
+	int i,j,offset_extreme,*flag;
+	double extreme;
+	flag=new int[Number];
+	memset(flag,0,sizeof(int)*Number);
+	for(i=0;i<Number;i++)
+	{
+		if(m_SortType==SortDescending)
+			extreme=-1E100;
+		else
+			extreme=1E100;
+		offset_extreme=0;
+		for(j=0;j<Number;j++)
+		{
+			if(flag[j]==1)
+				continue;
+			if( (m_SortType==SortDescending && extreme<pData[j]) || (m_SortType==SortAscending && extreme>pData[j]))
+			{
+				extreme=pData[j];
+				offset_extreme=j;
+			}
+		}
+		pIndex[i]=offset_extreme;
+		flag[offset_extreme]=1;
+	}
+	delete flag;
+}
+
+template <class T>
+T CStochastic::Min(int NumData,T* pData)
+{
+	int i;
+	T result=pData[0];
+	for(i=1;i<NumData;i++)
+		result=__min(result,pData[i]);
+	return result;
+}
+
+template <class T>
+T CStochastic::Min(int NumData,T* pData1,T* pData2)
+{
+	int i;
+	T result=pData1[0]+pData2[0];
+	for(i=1;i<NumData;i++)
+		result=__min(result,pData1[i]+pData2[i]);
+	return result;
+}
+
+template <class T>
+T CStochastic::Max(int NumData,T* pData)
+{
+	int i;
+	T result=pData[0];
+	for(i=1;i<NumData;i++)
+		result=__max(result,pData[i]);
+	return result;
+}
+
+template <class T>
+int CStochastic::FindMax(int NumData,T* pData)
+{
+	int i,index;
+	T result=pData[0];
+	index=0;
+	for(i=1;i<NumData;i++)
+		if(pData[i]>result)
+		{
+			index=i;
+			result=pData[i];
+		}
+	return index;
+}
+
+
+template <class T1,class T2>
+void CStochastic::ComputeMeanCovariance(int Dim,int NumData,T1* pData,T2* pMean,T2* pCovariance,double* pWeight)
+{
+	int i,j,k;
+	memset(pMean,0,sizeof(T2)*Dim);
+	memset(pCovariance,0,sizeof(T2)*Dim*Dim);
+	
+	bool IsWeightLoaded=false;
+	double Sum;
+	if(pWeight!=NULL)
+		IsWeightLoaded=true;
+
+	// compute mean first
+	Sum=0;
+	if(IsWeightLoaded)
+		for(i=0;i<NumData;i++)
+		{
+			if(pWeight[i]==0)
+				continue;
+			for(j=0;j<Dim;j++)
+				pMean[j]+=pData[i*Dim+j]*pWeight[i];
+			Sum+=pWeight[i];
+		}
+	else
+	{
+		for(i=0;i<NumData;i++)
+			for(j=0;j<Dim;j++)
+				pMean[j]+=pData[i*Dim+j];
+		Sum=NumData;
+	}
+	for(j=0;j<Dim;j++)
+		pMean[j]/=Sum;
+
+	//compute covariance;
+	T2* pTempVector;
+	pTempVector=new T2[Dim];
+
+	for(i=0;i<NumData;i++)
+	{
+		for(j=0;j<Dim;j++)
+			pTempVector[j]=pData[i*Dim+j]-pMean[j];
+		if(IsWeightLoaded)
+		{
+			if(pWeight[i]==0)
+				continue;
+			for(j=0;j<Dim;j++)
+				for(k=0;k<=j;k++)
+					pCovariance[j*Dim+k]+=pTempVector[j]*pTempVector[k]*pWeight[i];
+		}
+		else
+			for(j=0;j<Dim;j++)
+				for(k=0;k<=j;k++)
+					pCovariance[j*Dim+k]+=pTempVector[j]*pTempVector[k];
+	}
+	for(j=0;j<Dim;j++)
+		for(k=j+1;k<Dim;k++)
+			pCovariance[j*Dim+k]=pCovariance[k*Dim+j];
+
+	for(j=0;j<Dim*Dim;j++)
+		pCovariance[j]/=Sum;
+
+	delete []pTempVector;
+}
+
+template <class T1,class T2>
+void CStochastic::ComputeVectorMean(int Dim,int NumData,T1* pData,T2* pMean,double* pWeight)
+{
+	int i,j;
+	memset(pMean,0,sizeof(T2)*Dim);
+	bool IsWeightLoaded;
+	double Sum;
+	if(pWeight=NULL)
+		IsWeightLoaded=false;
+	else
+		IsWeightLoaded=true;
+
+	Sum=0;
+	if(IsWeightLoaded)
+		for(i=0;i<NumData;i++)
+		{
+			if(pWeight[i]==0)
+				continue;
+			for(j=0;j<Dim;j++)
+				pMean[j]+=pData[i*Dim+j]*pWeight[i];
+			Sum+=pWeight[i];
+		}
+	else
+	{
+		for(i=0;i<NumData;i++)
+			for(j=0;j<Dim;j++)
+				pMean[j]+=pData[i*Dim+j];
+		Sum=NumData;
+	}
+	for(j=0;j<Dim;j++)
+		pMean[j]/=Sum;
+}
+
+template <class T1,class T2>
+double CStochastic::VectorSquareDistance(int Dim,T1* pVector1,T2* pVector2)
+{
+	double result=0,temp;
+	int i;
+	for(i=0;i<Dim;i++)
+	{
+		temp=pVector1[i]-pVector2[i];
+		result+=temp*temp;
+	}
+	return result;
+}
+
+template <class T1>
+void CStochastic::KMeanClustering(int Dim,int NumData,int NumClusters,T1* pData,int *pPartition,double** pClusterMean,int MaxIterationNum, int MinClusterSampleNumber)
+{
+	int i,j,k,l,Index,ClusterSampleNumber;
+	double MinDistance,Distance;
+	double** pCenters;
+	pCenters=new double*[NumClusters];
+	for(i=0;i<NumClusters;i++)
+		pCenters[i]=new double[Dim];
+	
+	// generate randome guess of the partition
+_CStochastic_KMeanClustering_InitializePartition:
+	for(i=0;i<NumClusters;i++)
+	{
+		Index=UniformSampling(NumData);
+		for(j=0;j<Dim;j++)
+			pCenters[i][j]=pData[Index*Dim+j];
+	}
+
+	for(k=0;k<MaxIterationNum;k++)
+	{
+		// step 1. do partition
+		for(i=0;i<NumData;i++)
+		{
+			MinDistance=1E100;
+			for(j=0;j<NumClusters;j++)
+			{
+				Distance=VectorSquareDistance(Dim,pData+i*Dim,pCenters[j]);
+				if(Distance<MinDistance)
+				{
+					MinDistance=Distance;
+					Index=j;
+				}
+			}
+			pPartition[i]=Index;
+		}
+		// step 2. compute mean
+		for(i=0;i<NumClusters;i++)
+		{
+			memset(pCenters[i],0,sizeof(double)*Dim);
+			ClusterSampleNumber=0;
+			for(j=0;j<NumData;j++)
+				if(pPartition[j]==i)
+				{
+					for(l=0;l<Dim;l++)
+						pCenters[i][l]+=pData[j*Dim+l];
+					ClusterSampleNumber++;
+				}
+			// maybe the initial partition is bad
+			// if so just do initial partition again
+			if(ClusterSampleNumber<MinClusterSampleNumber)
+				goto _CStochastic_KMeanClustering_InitializePartition;
+			for(l=0;l<Dim;l++)
+				pCenters[i][l]/=ClusterSampleNumber;
+		}
+	}
+	// output the final partition if necessary
+	if(pClusterMean!=NULL)
+		for(i=0;i<NumClusters;i++)
+			for(l=0;l<Dim;l++)
+				pClusterMean[i][l]=pCenters[i][l];
+	// free buffer
+	for(i=0;i<NumClusters;i++)
+		delete pCenters[i];
+	delete []pCenters;
+}
+
+template <class T>
+double CStochastic::norm(T* X,int Dim)
+{
+	double result=0;
+	int i;
+	for(i=0;i<Dim;i++)
+		result+=X[i]*X[i];
+	result=sqrt(result);
+	return result;
+}
+
+template <class T1,class T2>
+int CStochastic::FindClosestPoint(T1* pPointSet,int NumPoints,int nDim,T2* QueryPoint)
+{
+	int i,j,Index=0,offset;
+	T1 MinDistance,Distance,x;
+	MinDistance=0;
+	for(j=0;j<nDim;j++)
+		MinDistance+=_abs(pPointSet[j]-QueryPoint[j]);
+	for(i=1;i<NumPoints;i++)
+	{
+		Distance=0;
+		offset=i*nDim;
+		for(j=0;j<nDim;j++)
+		{
+			x=pPointSet[offset+j]-QueryPoint[j];
+			Distance+=_abs(x);
+		}
+		if(Distance<MinDistance)
+		{
+			MinDistance=Distance;
+			Index=i;
+		}
+	}
+	return Index;
+}
+
+template <class T1,class T2>
+void CStochastic::GaussianFiltering(T1* pSrcArray,T2* pDstArray,int NumPoints,int nChannels,int size,double sigma)
+{
+	int i,j,u,l;
+	double *pGaussian,temp;
+	pGaussian=new double[2*size+1];
+	Generate1DGaussian(pGaussian,size,sigma);
+	for(i=0;i<NumPoints;i++)
+		for(l=0;l<nChannels;l++)
+		{
+			temp=0;
+			for(j=-size;j<=size;j++)
+			{
+				u=i+j;
+				u=__max(__min(u,NumPoints-1),0);
+				temp+=pSrcArray[u*nChannels+l]*pGaussian[j+size];
+			}
+			pDstArray[i*nChannels+l]=temp;
+		}
+	delete pGaussian;
+}
+
+#endif

UVDoc_official/eval/eval_code/SIFTflow/mexDiscreteFlow/main.cpp

@@ -0,0 +1,86 @@
+#include <QtGui/QApplication>
+#include <QtCore/QCoreApplication>
+#include "Image.h"
+#include "BPFlow.h"
+#include "stdio.h"
+#include "time.h"
+
+int main(int argc, char *argv[])
+{
+	time_t start,end;
+	 double dif;
+
+	QCoreApplication a(argc, argv);
+
+	time (&start);
+
+	BiImage im1,im2,Im1,Im2;
+	if(!im1.imread("sflowg.00.jpg"))
+	{
+		printf("Error in loading frame 1!");
+		return -1;
+	}
+	if(!im2.imread("sflowg.01.jpg"))
+	{
+		printf("Error in loading frame 2!");
+		return -1;
+	}
+	//if(!im1.imread("scene1.row2.jpg"))
+	//{
+	//	printf("Error in loading frame 1!");
+	//	return -1;
+	//}
+	//if(!im2.imread("scene1.row3.jpg"))
+	//{
+	//	printf("Error in loading frame 2!");
+	//	return -1;
+	//}
+
+	im1.GaussianSmoothing(Im1,.8,5);
+	im2.GaussianSmoothing(Im2,.8,5);
+	Im1.imresize(0.5);
+	Im2.imresize(0.5);
+	//Im1=im1;
+	//Im2=im2;
+
+	double alpha=0.03*255;
+	double gamma=0.002*255;
+	BPFlow bpflow;
+	int wsize=7;
+	
+	bpflow.setDataTermTruncation(true);
+	//bpflow.setTRW(true);
+	//bpflow.setDisplay(false);
+	bpflow.LoadImages(Im1.width(),Im1.height(),Im1.nchannels(),Im1.data(),Im2.data());
+	bpflow.setPara(alpha*2,alpha*20);
+	bpflow.setHomogeneousMRF(wsize);
+	bpflow.ComputeDataTerm();
+	bpflow.ComputeRangeTerm(gamma);
+	bpflow.MessagePassing(100,3);
+
+	//for(int i=0;i<55;i++)
+	//{
+	//	double CTRW=(i+1)*0.02;
+	//	bpflow.setCTRW(CTRW);
+	//	printf("No.%d CTRW=%f  energy=%f\n",i+1,CTRW,bpflow.MessagePassing(300,1));
+	//}
+	
+	//bpflow.MessagePassing(60);
+	bpflow.ComputeVelocity();
+
+	DImage vx(Im1.width(),Im1.height()),vy(Im1.width(),Im1.height());
+	for(int i=0;i<Im1.npixels();i++)
+	{
+		vx.data()[i]=bpflow.flow().data()[i*2];
+		vy.data()[i]=bpflow.flow().data()[i*2+1];
+	}
+	vx.imwrite("vx_discrete.jpg",ImageIO::normalized);
+	vy.imwrite("vy_discrete.jpg",ImageIO::normalized);
+
+	time (&end);
+	dif = difftime (end,start);
+    printf ("It took you %.2lf seconds to run SIFT flow.\n", dif );
+
+	//return a.exec();
+	return 1;
+}

UVDoc_official/eval/eval_code/SIFTflow/mexDiscreteFlow/mexDiscreteFlow.cpp

@@ -0,0 +1,130 @@
+#include "mex.h"
+#include "project.h"
+#include "Image.h"
+#include "BPFlow.h"
+
+double* outputMatrix2(mxArray*& plhs,int n1,int n2)
+{
+	mwSize dims[2];
+	dims[0]=n1;
+	dims[1]=n2;
+	plhs=mxCreateNumericArray(2,dims,mxDOUBLE_CLASS,mxREAL);
+	return (double *)mxGetData(plhs);
+}
+
+double* outputMatrix3(mxArray*& plhs,int n1,int n2,int n3)
+{
+	mwSize dims[3];
+	dims[0]=n1;
+	dims[1]=n2;
+	dims[2]=n3;
+	plhs=mxCreateNumericArray(3,dims,mxDOUBLE_CLASS,mxREAL);
+	return (double *)mxGetData(plhs);
+}
+
+double* outputMatrix4(mxArray*& plhs,int n1,int n2,int n3,int n4)
+{
+	mwSize dims[4];
+	dims[0]=n1;
+	dims[1]=n2;
+	dims[2]=n3;
+	dims[3]=n4;
+	plhs=mxCreateNumericArray(4,dims,mxDOUBLE_CLASS,mxREAL);
+	return (double *)mxGetData(plhs);
+}
+
+
+void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
+{
+	BiImage Im1,Im2;
+	Im1.LoadMatlabImage(prhs[0]);
+	Im2.LoadMatlabImage(prhs[1]);
+
+	
+	// define parameters
+	double alpha=0.01;
+	double d=1;
+	double gamma=0.001;
+	int nIterations=40;
+	int nHierarchy=2;
+	int wsize=5;
+
+	// load the parameters for matching
+    if(nrhs>=3)
+    {
+        int nDims=mxGetNumberOfDimensions(prhs[2]);
+		if(nDims>2)
+			mexErrMsgTxt("The third parameter must be a vector!");
+		const mwSize* dims=mxGetDimensions(prhs[2]);
+		if(dims[0]!=1 && dims[1]!=1)
+			mexErrMsgTxt("The third parameter must be a vector!");
+		int nPara=dims[0]+dims[1]-1;
+        double* para=(double *)mxGetData(prhs[2]);
+
+        if(nPara>=1)
+            alpha=para[0];
+        if(nPara>=2)
+            d=para[1];
+        if(nPara>=3)
+			gamma=para[2];
+		if(nPara>=4)
+            nIterations=para[3];
+		if(nPara>=5)
+			nHierarchy=para[4];
+        if(nPara>=6)
+            wsize=para[5];
+    }
+	//printf("Alpha: %f   d: %f  gamma: %f  nIterations: %d   nHierarchy: %d   wsize: %d\n",alpha,d,gamma,nIterations,nHierarchy,wsize);
+	// load offset information
+	IntImage OffsetX,OffsetY;
+
+	if(nrhs>=5)
+	{
+		OffsetX.LoadMatlabImage(prhs[3],false); // there is no force of conversion
+		OffsetY.LoadMatlabImage(prhs[4],false);
+	}
+	
+	IntImage WinSizeX,WinSizeY;
+	if(nrhs>=7)
+	{
+		WinSizeX.LoadMatlabImage(prhs[5],false); // there is no force of conversion
+		WinSizeY.LoadMatlabImage(prhs[6],false);
+	}
+
+	DImage Im_s,Im_d;
+	if(nrhs==9)
+	{
+		Im_s.LoadMatlabImage(prhs[7],false); // no force of converstion
+		Im_d.LoadMatlabImage(prhs[8],false);
+	}
+	// output parameters
+	double* pEnergyList=NULL;
+	if(nlhs>1)
+		pEnergyList=outputMatrix2(plhs[1],1,nIterations);
+
+	// the main function goes here
+	BPFlow bpflow;
+	bpflow.LoadImages(Im1.width(),Im1.height(),Im1.nchannels(),Im1.data(),Im2.width(),Im2.height(),Im2.data());
+	
+	if(nrhs>7)
+		bpflow.setPara(Im_s,Im_d);
+	else
+		bpflow.setPara(alpha,d);
+	
+	bpflow.setHomogeneousMRF(wsize); // first assume homogeneous setup
+
+	if(nrhs>=4)
+		bpflow.LoadOffset(OffsetX.data(),OffsetY.data());
+
+	if(nrhs>=6)
+		bpflow.LoadWinSize(WinSizeX.data(),WinSizeY.data());
+
+	bpflow.ComputeDataTerm();
+	bpflow.ComputeRangeTerm(gamma);
+	
+	bpflow.MessagePassing(nIterations,nHierarchy,pEnergyList);
+	bpflow.ComputeVelocity();
+
+	bpflow.flow().OutputToMatlab(plhs[0]);
+
+}

UVDoc_official/eval/eval_code/SIFTflow/mexDiscreteFlow/mexDiscreteFlow.m

@@ -0,0 +1,47 @@
+% mex function to perform SIFT flow matching
+%
+% Usage:
+%
+% [flow,energylist] = mexDiscreteFlow(im1,im2,para);
+% [flow,energylist] = mexDiscreteFlow(im1,im2,para,offsetX,offsetY,winSizeX,winSizeY);
+%
+% ** Input arguments **
+%
+% Arguments "im1" and "im2" are SIFT images. SIFT flow is estimated from im1 to im2. Normally 
+% MATLAB function dense_sift is used to generate a dense SIFT image from a RGB image. The 
+% argument "para" is the a vector specifying the parameters of matching. Let
+%
+%   para = [alpha,d,gamma,nIterations,nHierarchy,wsize];
+%
+% where each element is defined as (the number in the parenthesis is the defaut value)
+%
+%       alpha:        (0.01) the weight of the truncated L1-norm regularization on the flow
+%       d:            (1) the threshold of the truncation
+%       gamma:        (0.001) the weight of the magnitude of the flow
+%       nIterations:  (40) the number of iterations
+%       nHierarchy:   (2)  the number of hierarchies in the efficient BP implementation
+%       wsize:        (5)  the half size of the search window 
+%
+% Notice that the two images are NOT required to have the same dimension. But certainly you
+% wouldn't expect to get anything meaningful if their dimensions are too different.
+%
+% Arguments "offsetX" and "offsetY" should have the same dimension (height and width) as im1.
+% These two parameters are introduced to handle coarse-to-fine SIFT flow matching. We can 
+% specify the center of the matching window by defining offsetX and offsetY. When these two
+% arguments are not specified, they are treated as 0.
+%
+% Arugments "winSizeX" and "winSizeY" should have also the same dimeiosn as im1. These two 
+% parameters are introduced to overwrite "wsize" in "para", to specify pixel-wise window size.
+%
+% ** Output arguments **
+% 
+% The first argument "flow" is a [h x w x 2] matrix where flow(:,:,1) is the horizontal component
+% and flow(:,:,2) is the vertical component. The height and weight of flow is the same as im1.
+%
+% The second argument "energylist" records the energy obtained by the BP algorithm at each 
+% iteration.
+%
+% Ce Liu
+% CSAIL, MIT
+% Jan, 2009
+% All rights reserved

UVDoc_official/eval/eval_code/SIFTflow/mexDiscreteFlow/project.h

@@ -0,0 +1,46 @@
+#pragma once
+#include "stdio.h"
+
+// if the files are compiled in linux or mac os then uncomment the following line, otherwise comment it if you compile using visual studio in windows
+#define _LINUX_MAC
+
+template <class T>
+void _Release1DBuffer(T* pBuffer)
+{
+	if(pBuffer!=NULL)
+		delete []pBuffer;
+	pBuffer=NULL;
+}
+
+template <class T>
+void _Rlease2DBuffer(T** pBuffer,size_t nElements)
+{
+	for(size_t i=0;i<nElements;i++)
+		delete [](pBuffer[i]);
+	delete []pBuffer;
+	pBuffer=NULL;
+}
+
+
+#define _MATLAB
+
+#ifdef _MATLAB
+#include "mex.h"
+#endif
+
+
+#ifdef _LINUX_MAC
+
+template <class T1,class T2>
+T1 __min(T1 a, T2 b)
+{
+  return (a>b)?b:a;
+}
+
+template <class T1,class T2>
+T1 __max(T1 a, T2 b)
+{
+  return (a<b)?b:a;
+}
+
+#endif

UVDoc_official/eval/eval_code/SIFTflow/mexDiscreteFlow/readme.txt

@@ -0,0 +1,12 @@
+The *.cpp and *.h files in this folder are used to mex a matlab dll file for SIFT flow matching. Use the following command to compile in Matlab (tested on version 7.6 or later)
+
+mex mexDiscreteFlow.cpp BPFlow.cpp Stochastic.cpp
+
+It has been tested in Windows 7 x64, Linux x64 and Mac OS 10.6. Precompiled versions of Windows 7 x64 and Mac OS 10.6 are included in the folder.
+
+
+------------------------- Important -------------------------
+
+You must change one line in order to compile correctly. On line 5 of project.h, you should comment this line if you are compiling using visual studio in windows, or uncomment if you are in linux or mac os.
+
+-------------------------------------------------------------

UVDoc_official/eval/eval_code/SIFTflow/readme.txt

@@ -0,0 +1,24 @@
+This is the software package of our TPAMI paper:
+
+C. Liu, J. Yuen and A. Torralba. SIFT Flow: Dense Correspondence across Scenes and its Applications. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 2010.
+
+Please cite our paper if you use our code for your research. Also, please notice that there is slight change in the package compared to the ECCV version. Obtaining dense SIFT features has been mexed.
+
+
+Please run demo.h first. If error appears, please go to "mexDenseSIFT" and "mexDiscreteFlow" subfolders and follow the instructions in readme.txt (yes, there is readme.txt in each folder) to compile the cpp files. 
+
+------------------------- Important -------------------------
+
+You must change one line in order to compile correctly. On line 5 of project.h, you should comment this line if you are compiling using visual studio in windows, or uncomment if you are in linux or mac os.
+
+-------------------------------------------------------------
+
+Run demo.m in MATLAB and you will see how SIFT flow works.
+
+Enjoy!
+
+
+Ce Liu
+
+Microsoft Research New England
+Sep 2010

UVDoc_official/eval/eval_code/SIFTflow/warpFL.m

@@ -0,0 +1,7 @@
+% warp i2 according to flow field in vx vy
+function [warpI2,I]=warp(i2,vx,vy)
+[M,N]=size(i2);
+[x,y]=meshgrid(1:N,1:M);
+warpI2=interp2(x,y,i2,x+vx,y+vy,'bicubic');
+I=find(isnan(warpI2));
+warpI2(I)=zeros(size(I));