135 files changed, 9772 insertions, 0 deletions

diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/ChangeLog b/SD-VBS/benchmarks/texture_synthesis/src/matlab/ChangeLog
new file mode 100755
index 0000000..f20c499
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/ChangeLog
@@ -0,0 +1,430 @@
+           Log of changes made to matlabPyrTools code
+                (important changes marked with **)
+----------------------------------------------------------------------- 
+2004-10-14  Eero Simoncelli  <eero@sesto.cns.nyu.edu>
+
+        * Made new tarfile (version 1.3) 
+        
+        * Incorporated complex-valued steerable pyramid code (buildSCFpyr,
+        buildSCFpyrLevs,reconSCFpyr) written by Javier Portilla in 9/97,
+        and used in our work on texture representation/synthesis
+        (Portilla&Simoncelli, Int'l Journal of Computer Vision,
+        40(1):49-71, Dec 2000).
+        
+        * Incorporated imGradient.m from personal code.
+        
+        * reagan.pgm out.  feynam.pgm in
+        
+2004-03-20  Eero Simoncelli  <eero@sesto.cns.nyu.edu>
+
+        * blur.m added (just calls blurDn and then upBlur).
+        
+2003-08-06  Eero Simoncelli  <eero@sesto.cns.nyu.edu>
+
+        * blurDn.m (filt): Forced correct scaling of filters in  1D
+
+2003-05-28  Eero Simoncelli  <eero@ferrando.cns.nyu.edu>
+
+        * incorporated setPyrBand.m from local code
+
+2002-10-01  Eero Simoncelli  <eero.simoncelli@nyu.edu>
+
+        * incorporated clip.m from local code
+
+2002-09-18  Eero Simoncelli  <eero.simoncelli@nyu.edu>
+
+        * pointOp.m: Added the new 'extrap' option for matlab's interp1 to
+          make this m-file version more compatible with the mex version.
+
+Wed Aug 28 2002  Eero Simoncelli  <eero.simoncelli@nyu.edu>
+
+        * var2.m: now returns zero (instead of error) for matrix of size 1.
+        * function VECTORIZE renamed to VECTIFY, since it was colliding
+          with a function introduced in standard matlab.
+        
+Dec 27 2001  Eero Simoncelli  <eero.simoncelli@nyu.edu>
+
+        * Modified calls to upConv in reconSpyr.m and reconSpyrLevs.m so
+        that the returned result is bound.  Previously, had relied on the
+        MEX version of upConv to destructively modify the result array,
+        users had been getting errors because they were using the m-file
+        version of upConv.
+        
+Wed Sep 19 2001  Eero Simoncelli  <eero.simoncelli@nyu.edu>
+        
+        * buildSFpyrLevs/reconSFpyrLevs: replace use of "i" with sqrt(-1), to
+          avoid  problems if user rebinds it!
+        
+Wed Mar 28 10:22:01 2001  Eero Simoncelli  <eero.simoncelli@nyu.edu>
+
+        * Moved innerProd.m and all associated MEX files from the
+        matlabLocal source tree into matlabPyrTools.  
+        * Added innerProd to Contents.m
+        * Updated/clarified WARNINGS in all *.m files that have MEX versions.
+        
+Tue Mar 27 11:21:53 2001  Eero Simoncelli  <eero.simoncelli@nyu.edu>
+
+        * Incorporated Windows MEX files (*.dll) into MEX subdirectory.
+         Windows users should either copy these into the main directory,
+         or put the MEX subdirectory in their matlab path.
+        
+Fri Mar 23 14:46:16 2001  Eero Simoncelli  <eero.simoncelli@nyu.edu>
+
+        * buildSFpyrLevs.m, reconSFpyrLevs.m: shift the raised-cosine
+        lookup table (Xrcos) instead of incrementing the log-radial image
+        (log_rad).  THis is more efficient...
+
+Fri Oct  1 19:37:03 1999  Eero Simoncelli  <eero.simoncelli@nyu.edu>
+
+        * upConv.m: Did not return correct size result when STOP argument
+        was passed.  Thanks to hertzman@mrl.nyu.edu for pointing this out.
+        
+Fri Sep 17 15:53:26 1999  Eero Simoncelli  <eero.simoncelli@nyu.edu>
+
+        * buildSFpyrLevs.m: Changed lutsize to 1024, giving a slight
+        increase in accuracy.
+
+Thu Feb 25 18:10:38 1999  Eero Simoncelli  <eero.simoncelli@nyu.edu>
+
+        * histo1.m: Modified histo.m to be more compatible (but still not
+        exactly the same) as the MEX file version.
+
+Fri Jun 12 21:15:39 1998  Eero Simoncelli  <eero.simoncelli@nyu.edu>
+
+        * TUTORIALS pyramids.m upgraded.
+
+Tue Feb 17 13:22:28 1998  Eero Simoncelli  <eero.simoncelli@nyu.edu>
+
+        * showIm.m: Dims are now printed followed by the zoom factor.
+
+Mon Oct 13 14:49:51 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * mkSquare.m: Modified to do raised-cosine soft threshold
+        transitions.
+
+Tue Oct  7 10:13:51 1997  Eero Simoncelli  <eero@chrysothemis.cims.nyu.edu>
+
+        * upConv.m: Argument order was wrong (this function is not used
+        anyway, unless you don't compile the MEX code). - Thanks to
+        farid@psyche.mit.edu for pointing this out.
+
+Thu Sep 25 16:09:49 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * MEX/wrap.c: Changed #include <malloc.h> to <stdlib.h>, as
+        suggested by David Brainard.  * Incorporated Mac-compiled mex
+        files, courtesy of David Brainard.
+        
+Sat Sep  6 16:10:25 1997  Eero Simoncelli  <eero@chrysothemis.cims.nyu.edu>
+
+        * MEX/convolve.h:  abstracted out type of images with typedef image_type.
+        Added ansi declarations.
+        
+Fri Aug 29 13:49:16 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        ** showIm.m: Modified to behave better under resizing (and printing):
+        resets axis units to "normalized".
+
+Thu Aug 28 22:56:52 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        ** MEX/edges.c: reflect1, reflect2, repeat, extend upgraded to work
+        properly for non-symmetric filters.  reflect2 and extend were also
+        broken for upConv.  Added qreflect2 to handle even-length QMF's
+        which broke under the reflect2 modification.
+        * Added example code to TUTORIALS/matlabPyrTools to illustrate the
+        boundary-handling behavior...
+        
+Thu Aug 21 13:34:17 1997  Eero Simoncelli  <eero@chrysothemis.cims.nyu.edu>
+
+        * var2, skew2, kurt2: modified to return complex values for complex images.
+        * imStats.m: now gives an error for complex args.
+
+Thu Aug 14 15:24:29 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * Modified shift.m: negated the meaning of the offset parameter,
+        such that RES=shift(MTX,OFFSET) means RES(POS)=MTX(POS-OFFSET)
+        (this is more intuitive).
+
+Thu Jul 10 17:06:52 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * Modified MEX/Makefile-* to be consistent with matlab5:
+           - call mex instead of cmex
+           - use -V4 flag (creating matlab v4 compatible binaries)
+        
+        * showIm.m (xlbl_offset): Modified to use "points" units, so that
+        printed images look correct.  Still slightly busted for arbitrary figure
+        window sizes and for printing.
+        
+        * Modified upConv.c: does not return ANYTHING if you pass a result
+        argument (this had been causing occasional problems with matlab's 
+        memory manager).
+        
+Mon Jun 30 12:09:30 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * reconSFpyr.m (res): now returns real part (oops).
+
+        * reconSpyrLevs.m (maxLev): got rid of superfluous nbands argument
+        (can be calculated from bfilts).
+
+Mon May 26 12:29:54 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * showIm.m/pgmWrite.m: Modified 'auto3'-scaling to use a
+        histogram.  This gives a significant speedup.
+
+        * fixed a few minor bugs in the TUTORIALS, having to do with 
+        matching image sizes to the machine speed...
+
+Sat May 10 17:27:25 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * pgmWrite.m: fixed auto-scaling bug.  Added new scaling
+        calculations, parallel to those of imShow.
+
+Fri May  9 09:02:56 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * buildSFpyr.m: Changed NBANDS argument to be ORDER, which is one
+        less than the number of orientation bands.  This is consistent
+        with the derivative order, and the labels on the spNFilters files.
+
+Tue May  6 19:08:18 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        ** Added buildSFpyr, reconSFpyr: Steerable pyramids constructed
+        in the Fourier domain.  Radial functions tile, with a
+        raised-cosine falloff.  Angular functions are
+        cos(theta-k\pi/(K+1))^K, where K is the order (number of bands
+        minus 1).  Compared to the convolution version:
+            + Reconstruction is exact (within floating point errors) 
+            + Can produce any number of orientation bands. 
+            - Typically slower.
+            - Boundary-handling must be circular.
+        Could be made much more efficient by taking advantage of symmetries in
+        the fft!
+        
+        * Added example usage of Fourier steerable pyramid to TUTORIALS/pyramids.m
+        
+        * steer.m:  fixed for harmonic lists including zero.
+
+Sun May  4 15:16:10 1997  Eero Simoncelli  <eero@ferrando.cns.nyu.edu>
+
+        * MEX/Makefile-linux: created.
+        
+        * spyrHt, spyrNumBands: Modified to return 0 for pyramids of height 0.
+        
+        * reconWpyr.m: utilize desctructive addition in calls to upConv.
+        
+        * reconSpyr.m: Added error check to ensure consistancy between
+        pyramid and filter file.  Utilize destructive addition in upConv
+        call on highpass band.  Modified to work properly with pyramids of
+        height 0.
+        
+Mon Apr 28 13:38:10 1997  Eero Simoncelli  <eero@ferrando.cns.nyu.edu>
+
+        * lplot.m: modified to handle complex vectors,  use standard MatLab 
+          indices, and show minimal axes.  Added xrange parameter to allow
+          adjustment of X axis labeling.
+
+Sun Apr 27 20:20:41 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * var2, skew2, kurt2: enhanced to work on complex matrices.
+        
+Sat Apr 26 11:16:12 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * Changed parent directory (and distribution) name:
+                   matlabImTools -> matlabPyrTools
+
+        * namedFilter.m: Added two more Daubechies filters, and modified
+        names to match the reference (e.g., daub2 is now a 4-tap filter).
+
+        * Added vectorize.m: trivial function to pack matrix into vector (i.e., 
+        computes mtx(:)).
+        
+        * Added upBlur.m: Upsample and blur (parallels blurDn).
+
+Sun Apr 13 14:23:38 1997  Eero Simoncelli  <eero@chrysothemis.cims.nyu.edu>
+
+        * TUTORIALS/pyramids.m: Added plots of Fourier spectra for Wavelet bases.
+        
+        * make-tar-file: switched from compress to  gzip  for the
+        distribution tarfile.
+
+        * namedFilter.m: Added a few even-length QMF's from Johnston80.
+
+Fri Apr 11 19:16:21 1997  Eero Simoncelli  <eero@chrysothemis.cims.nyu.edu>
+
+        * buildWpyr.m, reconWpyr.m: Modified slightly, so that subsampling
+        lattice is better for even-length filters.
+        
+        * TUTORIALS/pyramids.m: Substantially overhauled.
+        
+Thu Apr 10 15:20:23 1997  Eero Simoncelli  <eero@chrysothemis.cims.nyu.edu>
+
+        * blurDn.m: added this function to downsample an image by a factor
+        2^L.
+
+        * Fixed minor bug in upConv.m: errors in image size checking.
+
+Mon Apr  7 13:25:37 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * Changed TUTORIALS/matlabImTools.m to use histo.mex instead of
+        matlab's hist.
+
+Wed Apr  2 13:20:55 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        ** Incorporated Denis Pelli's ThinkC and MetroWorks projects for
+        Macintosh versions of the MEX code, along with MEX binaries.  These
+        are included as an HQX'ed self-extracting archive
+        (Macintosh-MEX.sit.hqx), in the MEX subdirectory.
+
+Tue Apr  1 15:35:31 1997  Eero Simoncelli  <eero@chrysothemis.cims.nyu.edu>
+
+        * edges.c: modified by Denis Pelli to support THINK C.  * edges.c:
+        
+        * histo.c, upConv.c, corrDn.c: minor changes in error message
+        printouts, to work around bugs in THINK C.
+        
+        * Included Denis Pelli's MacReadMe file in the MEX subdirectory,
+        which gives instructions for MEX file compilation on a MacIntosh
+        (PPC or 68k).
+        
+        * wrap.c, convolve.c, edges.c: added explicit int function
+        declarations, and return values.
+
+        * range2.m/range2.c: A MEX function for fast min/max computation.
+        Adjusted entropy2.m, histo.m, imStats.m, pgmWrite.m, showIm.m,
+        showLpyr.m, showSpyr.m, showWpyr.m to call it.
+          
+Thu Mar 27 17:23:05 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        ** histo.m/histo.c: Added MEX function HISTO, a fast replacement
+        for matlab's HIST function.  Modified histoMatch.m, entropy2.m to
+        call it.
+        
+        * Changed main directory  name to matlabImTools.
+        
+        * Added TUTORIALS/README file.
+        
+Wed Mar 19 14:19:51 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * Changed directory name: MEX_SRC -> MEX
+
+Wed Mar 12 17:00:03 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * mkGaussian.m: fixed another (X,Y) bug: both dimensions and 
+        cov/mean are now specified in [y,x] order.
+
+Tue Mar 11 19:08:17 1997  Eero Simoncelli  <eero@chrysothemis.cims.nyu.edu>
+
+        * showSpyr.m: Fixed a bug that was dropping display of one
+        orientation band when there were more than 2 of them!
+
+Mon Mar 10 19:08:24 1997  Eero Simoncelli  <eero@chrysothemis.cims.nyu.edu>
+
+        * Added shift.m
+        
+        * makeSteerMtx -> steerDir2HarmMtx
+        
+        * Added TUTORIALS/matlab-EPS.m: examples using the code in this
+        distribution.
+
+Sun Mar  9 17:49:18 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        ** showIm.m:  
+          - args: changed order so that NSHADES is last.
+          - TITLES: Can now pass a string for IM, which will be evaluated
+            in the global environment to get the matrix.  The string is
+            used as a title.  MATLAB v.5 ONLY!!!
+          - Added 'auto3' RANGE value, that scales based on percentiles.
+            THis is more robust to outliers than 'auto2' or 'auto1'.
+        
+        * pixelAxes.m: Made a more serious attempt to reverse-engineer
+          Mathworks' image pixelization.  It is improved, but still makes
+          occasional errors.
+        
+        * Added skew2.m.
+        
+Fri Mar  7 10:11:07 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * pixelAxes.m: Modified to take an optional
+        ZOOM argument.  Fixed dimension ordering bug
+        (positions are reported (x,y), but mtx dims are (y,x)!)
+        
+        * showIm.m: Added an optional ZOOM argument.
+
+Thu Mar  6 14:17:19 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * Added showLpyr, showWpyr, showSpyr.  Modified
+        TUTORIALS/pyramids.m to use them.
+        
+        * added pixelAxes.m: Adjusts size (in pixels) of currently
+        displayed image to be a multiple of the matrix dimensions, 
+        thus eliminating display aliasing artifacts.
+         This is now called by all the "show" commands.
+
+Mon Mar  3 17:33:25 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * Fixed bug in pgmWrite (dimensions were written in reverse order).
+
+        * Fixed bug in showIm (X and Y coords were swapped on label display).
+        
+        * Fixed bug in reconLpyr (swapped X and Y coords on int_sz)
+        
+        * Changed calls to "reshape" to pass dimensions individually --
+        older version of matlab do not accept the reshape(mtx,[y x]) form.
+        
+        * Fixed bug in mkDisc: sz a scalar.
+        
+        * Added ifftshift.m
+        
+Fri Feb 28 11:07:20 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+        
+        * Re-worked TUTORIALS/pyramids.m
+
+        * buildGpyr and buildLpyr now use 1+maxPyrHt for default height.
+        
+        * Fixed buildGpyr to work on 1D signals.
+        
+        ** Gaussian/Laplacian/Wavelet pyramid build and recon functions:
+          - work properly with new corrDn/upConv.
+          - use separable convolutions 
+          - use destructive modification ability of upConv (less memory
+          allocation)
+        
+        * modulateFlipShift -> modulateFlip.
+        
+        * added lpyrHt, wpyrHt, spyrHt to return number of levels in a pyramid.
+        
+Thu Feb 27 15:39:53 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        * Changed angular coordinate systems to CLOCKWISE in mkRamp,
+        mkTheta, mkSine, mkSquare.  This is unnatural for screen viewing,
+        but consistent with an origin in the upper left corner of the
+        image, which is the way one addresses the underlying matrix.
+
+        * mkSine and mkSquare can now take a frequency vector or the 
+          period and direction args
+        
+Tue Feb 25 11:58:33 1997  Eero Simoncelli  <eero@servilia.cns.nyu.edu>
+
+        ** Rewrote corrDn/upConv C routines:
+          - more efficient
+          - changed START parameters to have [1 1] origin, consistent with
+            matlab
+          - added STOP parameters
+          - upConv allows destructive modification of a result arg
+          - changed order of other params (sorry)
+          - wrote test file conv_test.m
+        * wrote zconv2.m
+
+Wed Aug 19 20:39:15 1996  Eero Simoncelli  (eero@tarpon.cis.upenn.edu)
+
+        ** Added "pointOp" function (MUCH faster than interp1).
+        ** Added "histoMatch" function.
+
+Fri Aug  2 00:56:31 1996  Eero Simoncelli  (eero@tarpon.cis.upenn.edu)
+
+        * Changed all function/file-names to be of the form "fooBar".  *
+        Fixed entropy2.m (busted due to typo).
+
+Original convolution code was written in Spring 1986, and comes from
+OBVIUS (Object-Based Vision and Image Understanding System), an
+interactive image-processing system written in Common Lisp (with calls
+to C code).
+        
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/Contents.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/Contents.m
new file mode 100755
index 0000000..d19f067
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/Contents.m
@@ -0,0 +1,107 @@
+% Image and Multi-scale Pyramid Tools
+% Version 1.3,  October 2004.
+% Created: Early Spring, 1996. Eero Simoncelli, eero.simoncelli@nyu.edu
+%
+% See README file for brief description.
+% See ChangeLog file for latest modifications. 
+% See TUTORIALS subdirectory for demonstrations.
+% Type "help <command-name>" for documentation on individual commands.
+% -----------------------------------------------------------------
+% Synthetic Images (matrices):
+%   mkImpulse  - Make an image containing an impulse.
+%   mkRamp     - Make an image containing a ramp function.
+%   mkR        - Make an image containing distance from the origin.
+%   mkAngle    - Make an image containing angle about origin.
+%   mkDisc     - Make an image containing a disk image.
+%   mkGaussian - Make an image containing a Gaussian function.
+%   mkZonePlate - Make an image containing a zone plate (cos(r^2)).
+%   mkAngularSine - Make an image containing an angular sine wave (pinwheel).
+%   mkSine     - Make an image containing a sine grating.
+%   mkSquare   - Make an image containing a square grating.
+%   mkFract    - Make an image containing fractal (1/f) noise.
+%
+% Point Operations:
+%   clip       - clip values to a range. 
+%   pointOp    - Lookup table (much faster than interp1) [MEX file]
+%   histo      - Efficient histogram computation [MEX file]
+%   histoMatch - Modify matrix elements to match specified histogram stats.
+%
+% Convolution (first two are significantly faster):
+%   corrDn     - Correlate & downsample with boundary-handling [MEX file]
+%   upConv     - Upsample & convolve with boundary-handling [MEX file]
+%   blurDn     - Blur and subsample a signal/image.
+%   upBlur     - Upsample and blur a signal/image.
+%   blur       - Multi-scale blurring, calls blurDn and then upBlur.
+%   cconv2     - Circular convolution.
+%   rconv2     - Convolution with reflected boundaries.
+%   zconv2     - Convolution assuming zeros beyond image boundaries.
+%
+% General pyramids:
+%   pyrLow     - Access lowpass subband from (any type of) pyramid
+%   pyrBand    - Access a subband from (any type of) pyramid
+%   setPyrBand - Insert an image into (any type of) pyramid as a subband 
+%   pyrBandIndices - Returns indices for given band in a pyramid vector
+%   maxPyrHt   - compute maximum number of scales in a pyramid
+%
+% Gaussian/Laplacian Pyramids:
+%   buildGpyr  - Build a Gaussian pyramid of an input signal/image.
+%   buildLpyr  - Build a Laplacian pyramid of an input signal/image.
+%   reconLpyr  - Reconstruct (invert) the Laplacian pyramid transform.
+%
+% Separable orthonormal QMF/wavelet Pyramids:
+%   buildWpyr  - Build a separable wavelet representation of an input signal/image.
+%   reconWpyr  - Reconstruct (invert) the wavelet transform.
+%   wpyrBand   - Extract a single band of the wavelet representation.
+%   wpyrLev    - Extract (packed) subbands at a particular level
+%   wpyrHt     - Number of levels (height) of a wavelet pyramid.
+%
+% Steerable Pyramids:
+%   buildSpyr  - Build a steerable pyramid representation of an input image.
+%   reconSpyr  - Reconstruct (invert) the steerable pyramid transform.
+%   buildSFpyr - Build a steerable pyramid representation in the Fourier domain.
+%   reconSFpyr - Reconstruct (invert) the (Fourier domain) steerable pyramid transform.
+%   spyrBand   - Extract a single band from a steerable pyramid.
+%   spyrHigh   - Highpass residual band.
+%   spyrLev    - A whole level (i.e., all images at a given scale) of a steerable pyramid.
+%   spyrHt     - Number of levels (height) of a steerable pyramid.
+%   spyrNumBands - Number of orientation bands in a steerable pyramid.
+%
+% Steerable filters / derivatives:
+%   imGradient - Compute gradient of image using directionally accurete filters.
+%   steer      - Steer filters (or responses).
+%   steer2HarmMtx - Construct a matrix mapping direcional basis to angular harmonics. 
+% 
+% Filters:
+%   binomialFilter  - returns a filter of binomial coefficients.
+%   namedFilter     - some typical Laplacian/Wavelet pyramid filters
+%   spNFilters      - Set of Nth order steerable pyramid filters.
+%   derivNFiltersS  - Matched set of S-tap 1D derivatives, orders 0 to N.
+% 
+% Display:
+%   showIm     - Display a matrix (real or complex) as grayscale image(s).
+%                Displays dimensions, subsampling, and range of pixel values.
+%   showLpyr   - Display a Laplacian pyramid.
+%   showWpyr   - Display a separable wavelet pyramid.
+%   showSpyr   - Display a steerable pyramid.
+%   lplot      - "lollipop" plot.
+%   nextFig    - Make next figure window current.
+%   pixelAxes  - Make image display use an integer number of pixels 
+%                per sample to avoid resampling artifacts.
+% 
+% Statistics (for 2D Matrices):
+%   range2     - Min and max of image (matrix) [MEX file]
+%   mean2      - Sample mean of an image (matrix). 
+%   var2       - Sample variance of an image (matrix). 
+%   skew2      - Sample skew (3rd moment / variance^1.5) of an image (matrix). 
+%   kurt2      - Sample kurtosis (4th moment / variance^2) of an image (matrix). 
+%   entropy2   - Sample entropy of an image (matrix).
+%   imStats    - Report sample statistics of an image, or pair of images.
+%
+% Miscellaneous:
+%   pgmRead    - Load a "pgm" image into a MatLab matrix [try einstein.pgm,feynman.pgm]
+%   pgmWrite   - Write a MatLab matrix to a "pgm" image file.
+%   shift      - circular shift a 2D matrix by an arbitrary amount.
+%   vectify    - pack matrix into column vector (i.e., function to compute mtx(:)).
+%   ifftshift  - inverse of MatLab's FFTSHIFT (differs for odd-length dimensions)
+%   rcosFn     - return a lookup table of a raised-cosine threshold fn.
+%   innerProd  - Compute M'*M efficiently (i.e., do not copy) [MEX file]
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/-MacReadMe b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/-MacReadMe
new file mode 100755
index 0000000..898dc0c
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/-MacReadMe
@@ -0,0 +1 @@
+MacReadMe
How to compile a MEX file for Macintosh
(Based on a similar note written by David Brainard and Denis Pelli to accompany the Psychophysics Toolbox.)

A MEX file (short for "MATLAB extension") contains code that implements a new MATLAB function, allowing users to use the full power of the C language and the Macintosh hardware and operating system in implementing a new MATLAB function. This document explains how to produce a MEX file that is "fat" (i.e. will run as native code on both 68K and PowerPC Macs) and is compatible with both MATLAB 4 and 5.

1) To produce a MATLAB MEX file with PowerPC code you must have the Metrowerks CodeWarrior C compiler (version 10 or better, abbreviated as CW below). To produce 68K code we still use the Symantec THINK C compiler (version from Symantec C++ 8 CD-ROM release 5), but we will soon be switching to Metrowerks CodeWarrior. (See note A below.)

2) Place a copy of the MATLAB 4:Extern folder, supplied by Mathworks, on your compiler's search path. We suggest that you name the copy "MEX V4". (See notes B and C, below.) 

3) Build any of the MEX files simply by opening its project file and asking your compiler to "Build Code Resource" (in THINK C) or to "Make" it (in CW).  For each MEX file, e.g. histo.mex, there are two associated projects, e.g. histo.µ for CW, and histo.¹.4 for THINK C. To build a "fat" MEX, that runs native on both 68K and PowerPC, you should first compile in THINK C, and then in CW. (See note A, below.)

Denis Pelli
April 2, 1997

Notes

A) The Mathworks support only the THINK C compiler to make 68K MEX code for MATLAB version 4 and only the CW compiler to make PPC MEX files for MATLAB 4 and both 68K and PPC for MATLAB 5. This archive includes THINK and CW projects. To build a fat MEX file for MATLAB 4, first "make" the THINK C version (e.g. histo.¹.4), producing a file with a .rsrc extension (e.g. histo.µ.rsrc). This is the 68K MEX file. When you then "make" histo.µ, the CW project incorporates the .rsrc file and generates a "fat" MEX file that will run native (i.e. fast) on both 68K and PowerPC. To make a 68K-only MEX file, simply rename, e.g., histo.µ.rsrc to histo.mex after you make the THINK project, and set the file type and creator to match the other MEX files. THINK C is slow and hard to work with. Symantec hasn't significantly upgraded in it many years. There is an error in the math.h header (version from Symantec C++ 8 CD-ROM release 5). We fix that error by some tricky preprocessor defines and undefines in the THINK C Prefix in each of the THINK projects. 

B) The easiest way to put a folder on your compilerÕs search path is simply to put the folder in the same folder as the compiler itself. If you want to use both CW and THINK C, then put the folder under CW, make an alias of it, and put the alias in THINK C's "Aliases" folder.

C) Happily, MATLAB 5 is capable of running both V4 and V5 MEX files. Thus we are currently distributing sources that compile into V4 MEX files. The resulting MEX files run both under V4 and V5. In the future we will drop support for V4 and THINK C. (See note A above.) 
\ No newline at end of file
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/.AppleDouble/.Parent b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/.AppleDouble/.Parent
new file mode 100755
index 0000000..f242a99
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/.AppleDouble/.Parent
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/.FBCIndex b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/.FBCIndex
new file mode 100755
index 0000000..848736b
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/.FBCIndex
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/.FBCLockFolder/.FBCSemaphoreFile b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/.FBCLockFolder/.FBCSemaphoreFile
new file mode 100755
index 0000000..ab2c684
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/.FBCLockFolder/.FBCSemaphoreFile
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-linux b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-linux
new file mode 100755
index 0000000..726dd31
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-linux
@@ -0,0 +1,39 @@
+MLAB = /usr/local/matlab5.1
+
+MXSFX = mexlx
+MEX = ${MLAB}/bin/mex
+
+MFLAGS = -V4
+INC = -I ${MLAB}/extern/include
+LIB = -L ${MLAB}/extern/lib
+
+CC = gcc -Wall -pedantic
+C_OPTIMIZE_SWITCH = -O2    ## For GCC
+CFLAGS = ${C_OPTIMIZE_SWITCH} ${INC} ${LIB}
+
+all: corrDn.${MXSFX} upConv.${MXSFX} pointOp.${MXSFX} \
+        histo.${MXSFX} range2.${MXSFX}
+
+clean:
+        /bin/rm *.o
+
+corrDn.${MXSFX}: corrDn.o wrap.o convolve.o edges.o
+        ${MEX} ${MFLAGS} corrDn.o wrap.o convolve.o edges.o
+
+upConv.${MXSFX}: upConv.o wrap.o convolve.o edges.o
+        ${MEX} ${MFLAGS} upConv.o wrap.o convolve.o edges.o
+
+pointOp.${MXSFX}: pointOp.o
+        ${MEX} ${MFLAGS} pointOp.o
+
+histo.${MXSFX}: histo.o
+        ${MEX} ${MFLAGS} histo.o
+
+range2.${MXSFX}: range2.o
+        ${MEX} ${MFLAGS} range2.o
+
+convolve.o wrap.o edges.o: convolve.h 
+
+%.o : %.c
+        ${CC} -c ${CFLAGS} $<           
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-ml6-linux b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-ml6-linux
new file mode 100755
index 0000000..f596ad7
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-ml6-linux
@@ -0,0 +1,39 @@
+MLAB = /usr/local/matlab6.0
+
+MXSFX = mexglx
+MEX = ${MLAB}/bin/mex
+
+MFLAGS = -V4
+INC = -I ${MLAB}/extern/include
+LIB = -L ${MLAB}/extern/lib
+
+CC = gcc -Wall -pedantic
+C_OPTIMIZE_SWITCH = -O2    ## For GCC
+CFLAGS = ${C_OPTIMIZE_SWITCH} ${INC} ${LIB}
+
+all: corrDn.${MXSFX} upConv.${MXSFX} pointOp.${MXSFX} \
+        histo.${MXSFX} range2.${MXSFX}
+
+clean:
+        /bin/rm *.o
+
+corrDn.${MXSFX}: corrDn.o wrap.o convolve.o edges.o
+        ${MEX} ${MFLAGS} corrDn.o wrap.o convolve.o edges.o
+
+upConv.${MXSFX}: upConv.o wrap.o convolve.o edges.o
+        ${MEX} ${MFLAGS} upConv.o wrap.o convolve.o edges.o
+
+pointOp.${MXSFX}: pointOp.o
+        ${MEX} ${MFLAGS} pointOp.o
+
+histo.${MXSFX}: histo.o
+        ${MEX} ${MFLAGS} histo.o
+
+range2.${MXSFX}: range2.o
+        ${MEX} ${MFLAGS} range2.o
+
+convolve.o wrap.o edges.o: convolve.h 
+
+%.o : %.c
+        ${CC} -c ${CFLAGS} $<           
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-osx b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-osx
new file mode 100755
index 0000000..352d15b
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-osx
@@ -0,0 +1,39 @@
+MLAB = /share/wotan/matlab13
+
+MXSFX = mexosx
+MEX = ${MLAB}/bin/mex
+
+MFLAGS =
+INC = -I ${MLAB}/extern/include
+LIB = -L ${MLAB}/extern/lib
+
+CC = cc -Wall -pedantic -no-cpp-precomp
+C_OPTIMIZE_SWITCH = -O2    ## For GCC
+CFLAGS = ${C_OPTIMIZE_SWITCH} ${INC} ${LIB}
+
+all: corrDn.${MXSFX} upConv.${MXSFX} pointOp.${MXSFX} \
+        histo.${MXSFX} range2.${MXSFX}
+
+clean:
+        /bin/rm *.o
+
+corrDn.${MXSFX}: corrDn.o wrap.o convolve.o edges.o
+        ${MEX} ${MFLAGS} corrDn.o wrap.o convolve.o edges.o
+
+upConv.${MXSFX}: upConv.o wrap.o convolve.o edges.o
+        ${MEX} ${MFLAGS} upConv.o wrap.o convolve.o edges.o
+
+pointOp.${MXSFX}: pointOp.o
+        ${MEX} ${MFLAGS} pointOp.o
+
+histo.${MXSFX}: histo.o
+        ${MEX} ${MFLAGS} histo.o
+
+range2.${MXSFX}: range2.o
+        ${MEX} ${MFLAGS} range2.o
+
+convolve.o wrap.o edges.o: convolve.h 
+
+%.o : %.c
+        ${CC} -c ${CFLAGS} $<           
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-solaris b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-solaris
new file mode 100755
index 0000000..2be2bdb
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-solaris
@@ -0,0 +1,38 @@
+MLAB = /export/home/Solaris2/matlab5.1
+
+MXSFX = mexsol
+MEX = ${MLAB}/bin/mex
+
+MFLAGS = -V4
+INC = -I ${MLAB}/extern/include
+LIB = -L ${MLAB}/extern/lib
+
+CC = gcc -Wall -pedantic
+C_OPTIMIZE_SWITCH = -O2    ## For GCC
+CFLAGS = ${C_OPTIMIZE_SWITCH} ${INC} ${LIB}
+
+all: corrDn.${MXSFX} upConv.${MXSFX} pointOp.${MXSFX} \
+        histo.${MXSFX} range2.${MXSFX}
+
+clean:
+        /bin/rm *.o
+
+corrDn.${MXSFX}: corrDn.o wrap.o convolve.o edges.o
+        ${MEX} ${MFLAGS} corrDn.o wrap.o convolve.o edges.o
+
+upConv.${MXSFX}: upConv.o wrap.o convolve.o edges.o
+        ${MEX} ${MFLAGS} upConv.o wrap.o convolve.o edges.o
+
+pointOp.${MXSFX}: pointOp.o
+        ${MEX} ${MFLAGS} pointOp.o
+
+histo.${MXSFX}: histo.o
+        ${MEX} ${MFLAGS} histo.o
+
+range2.${MXSFX}: range2.o
+        ${MEX} ${MFLAGS} range2.o
+
+convolve.o wrap.o edges.o: convolve.h 
+
+%.o : %.c
+        ${CC} -c ${CFLAGS} $<
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-sun4 b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-sun4
new file mode 100755
index 0000000..432b181
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/Makefile-sun4
@@ -0,0 +1,39 @@
+MLAB = /home/alberich/matlab4
+
+MXSFX = mex4
+MEX = ${MLAB}/bin/cmex
+
+MFLAGS = 
+INC = -I ${MLAB}/extern/include
+LIB = -L ${MLAB}/extern/lib/sun4
+
+CC = gcc
+C_OPTIMIZE_SWITCH = -O2    ## For GCC
+CFLAGS = ${C_OPTIMIZE_SWITCH} ${INC} ${LIB}
+
+all: corrDn.${MXSFX} upConv.${MXSFX} pointOp.${MXSFX} \
+        histo.${MXSFX} range2.${MXSFX}
+
+clean:
+        /bin/rm *.o
+
+corrDn.${MXSFX}: corrDn.o wrap.o convolve.o edges.o
+        ${MEX} ${MFLAGS} corrDn.o wrap.o convolve.o edges.o
+
+upConv.${MXSFX}: upConv.o wrap.o convolve.o edges.o
+        ${MEX} ${MFLAGS} upConv.o wrap.o convolve.o edges.o
+
+pointOp.${MXSFX}: pointOp.o
+        ${MEX} ${MFLAGS} pointOp.o
+
+histo.${MXSFX}: histo.o
+        ${MEX} ${MFLAGS} histo.o
+
+range2.${MXSFX}: range2.o
+        ${MEX} ${MFLAGS} range2.o
+
+convolve.o wrap.o edges.o: convolve.h 
+
+%.o : %.c
+        ${CC} -c ${CFLAGS} $<           
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/convolve.c b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/convolve.c
new file mode 100755
index 0000000..60a11a4
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/convolve.c
@@ -0,0 +1,325 @@
+/* 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  File: convolve.c
+;;;  Author: Eero Simoncelli
+;;;  Description: General convolution code for 2D images
+;;;  Creation Date: Spring, 1987.
+;;;  MODIFICATIONS:
+;;;     10/89: approximately optimized the choice of register vars on SPARCS.
+;;;      6/96: Switched array types to double float.
+;;;      2/97: made more robust and readable.  Added STOP arguments.
+;;;      8/97: Bug: when calling internal_reduce with edges in {reflect1,repeat,
+;;;            extend} and an even filter dimension.  Solution: embed the filter
+;;;            in the upper-left corner of a filter with odd Y and X dimensions.
+;;;  ----------------------------------------------------------------
+;;;    Object-Based Vision and Image Understanding System (OBVIUS),
+;;;      Copyright 1988, Vision Science Group,  Media Laboratory,  
+;;;              Massachusetts Institute of Technology.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+*/
+
+#include <stdio.h>
+#include <math.h>
+#include "convolve.h"
+
+/*
+  --------------------------------------------------------------------
+  Correlate FILT with IMAGE, subsampling according to START, STEP, and
+  STOP parameters, with values placed into RESULT array.  RESULT
+  dimensions should be ceil((stop-start)/step).  TEMP should be a
+  pointer to a temporary double array the size of the filter.
+  EDGES is a string specifying how to handle boundaries -- see edges.c.
+  The convolution is done in 9 sections, where the border sections use
+  specially computed edge-handling filters (see edges.c). The origin 
+  of the filter is assumed to be (floor(x_fdim/2), floor(y_fdim/2)).
+------------------------------------------------------------------------ */
+
+/* abstract out the inner product computation */
+#define INPROD(XCNR,YCNR)  \
+        { \
+        sum=0.0; \
+        for (im_pos=YCNR*x_dim+XCNR, filt_pos=0, x_filt_stop=x_fdim; \
+             x_filt_stop<=filt_size; \
+             im_pos+=(x_dim-x_fdim), x_filt_stop+=x_fdim) \
+            for (; \
+                 filt_pos<x_filt_stop; \
+                 filt_pos++, im_pos++) \
+              sum+= image[im_pos]*temp[filt_pos]; \
+        result[res_pos] = sum; \
+        }
+
+int internal_reduce(image, x_dim, y_dim, filt, temp, x_fdim, y_fdim,
+                x_start, x_step, x_stop, y_start, y_step, y_stop,
+                result, edges)
+  register image_type *image, *temp;
+  register int x_fdim, x_dim;
+  register image_type *result;
+  register int x_step, y_step;
+  int x_start, y_start;
+  int x_stop, y_stop;     
+  image_type *filt; 
+  int y_dim, y_fdim;
+  char *edges;
+  { 
+  register double sum;
+  register int filt_pos, im_pos, x_filt_stop;
+  register int x_pos, filt_size = x_fdim*y_fdim;
+  register int y_pos, res_pos;
+  register int y_ctr_stop = y_dim - ((y_fdim==1)?0:y_fdim);
+  register int x_ctr_stop = x_dim - ((x_fdim==1)?0:x_fdim);
+  register int x_res_dim = (x_stop-x_start+x_step-1)/x_step;
+  int x_ctr_start = ((x_fdim==1)?0:1);
+  int y_ctr_start = ((y_fdim==1)?0:1);
+  int x_fmid = x_fdim/2;
+  int y_fmid = y_fdim/2;
+  int base_res_pos;
+  fptr reflect = edge_function(edges);  /* look up edge-handling function */
+
+  if (!reflect) return(-1);
+
+  /* shift start/stop coords to filter upper left hand corner */
+  x_start -= x_fmid;   y_start -=  y_fmid;
+  x_stop -=  x_fmid;   y_stop -=  y_fmid;
+
+  if (x_stop < x_ctr_stop) x_ctr_stop = x_stop;
+  if (y_stop < y_ctr_stop) y_ctr_stop = y_stop;
+
+  for (res_pos=0, y_pos=y_start;              /* TOP ROWS */
+       y_pos<y_ctr_start;
+       y_pos+=y_step)
+    {
+    for (x_pos=x_start;                       /* TOP-LEFT CORNER */
+         x_pos<x_ctr_start;
+         x_pos+=x_step, res_pos++)
+      {
+      (*reflect)(filt,x_fdim,y_fdim,x_pos-1,y_pos-1,temp,REDUCE);
+      INPROD(0,0)
+      }
+
+    (*reflect)(filt,x_fdim,y_fdim,0,y_pos-1,temp,REDUCE);
+    for (;                                    /* TOP EDGE */
+         x_pos<x_ctr_stop;
+         x_pos+=x_step, res_pos++) 
+      INPROD(x_pos,0)
+
+    for (;                                    /* TOP-RIGHT CORNER */
+         x_pos<x_stop;
+         x_pos+=x_step, res_pos++) 
+      {
+      (*reflect)(filt,x_fdim,y_fdim,x_pos-x_ctr_stop+1,y_pos-1,temp,REDUCE);
+      INPROD(x_ctr_stop,0)
+      }
+    } /* end TOP ROWS */   
+
+  y_ctr_start = y_pos;                        /* hold location of top */
+  for (base_res_pos=res_pos, x_pos=x_start;   /* LEFT EDGE */
+       x_pos<x_ctr_start;
+       x_pos+=x_step, base_res_pos++)
+    {
+    (*reflect)(filt,x_fdim,y_fdim,x_pos-1,0,temp,REDUCE);
+    for (y_pos=y_ctr_start, res_pos=base_res_pos;
+         y_pos<y_ctr_stop;
+         y_pos+=y_step, res_pos+=x_res_dim)
+      INPROD(0,y_pos)
+    }
+
+  (*reflect)(filt,x_fdim,y_fdim,0,0,temp,REDUCE);
+  for (;                                      /* CENTER */
+       x_pos<x_ctr_stop;
+       x_pos+=x_step, base_res_pos++) 
+    for (y_pos=y_ctr_start, res_pos=base_res_pos;
+         y_pos<y_ctr_stop;
+         y_pos+=y_step, res_pos+=x_res_dim)
+      INPROD(x_pos,y_pos)
+
+  for (;                                      /* RIGHT EDGE */
+       x_pos<x_stop;
+       x_pos+=x_step, base_res_pos++)
+    {
+    (*reflect)(filt,x_fdim,y_fdim,x_pos-x_ctr_stop+1,0,temp,REDUCE);
+    for (y_pos=y_ctr_start, res_pos=base_res_pos;
+         y_pos<y_ctr_stop;
+         y_pos+=y_step, res_pos+=x_res_dim)
+      INPROD(x_ctr_stop,y_pos)
+    }
+
+  for (res_pos-=(x_res_dim-1);
+       y_pos<y_stop;                          /* BOTTOM ROWS */
+       y_pos+=y_step) 
+    {
+    for (x_pos=x_start;                       /* BOTTOM-LEFT CORNER */
+         x_pos<x_ctr_start;
+         x_pos+=x_step, res_pos++)
+      {
+      (*reflect)(filt,x_fdim,y_fdim,x_pos-1,y_pos-y_ctr_stop+1,temp,REDUCE);
+      INPROD(0,y_ctr_stop)
+      }
+
+    (*reflect)(filt,x_fdim,y_fdim,0,y_pos-y_ctr_stop+1,temp,REDUCE);
+    for (;                                    /* BOTTOM EDGE */
+         x_pos<x_ctr_stop;
+         x_pos+=x_step, res_pos++) 
+      INPROD(x_pos,y_ctr_stop)
+
+    for (;                                    /* BOTTOM-RIGHT CORNER */
+         x_pos<x_stop;
+         x_pos+=x_step, res_pos++) 
+      {
+      (*reflect)(filt,x_fdim,y_fdim,x_pos-x_ctr_stop+1,y_pos-y_ctr_stop+1,temp,REDUCE);
+      INPROD(x_ctr_stop,y_ctr_stop)
+      }
+    } /* end BOTTOM */
+  return(0);
+  } /* end of internal_reduce */
+
+
+/*
+  --------------------------------------------------------------------
+  Upsample IMAGE according to START,STEP, and STOP parameters and then
+  convolve with FILT, adding values into RESULT array.  IMAGE
+  dimensions should be ceil((stop-start)/step).  See
+  description of internal_reduce (above).
+
+  WARNING: this subroutine destructively modifies the RESULT array!
+ ------------------------------------------------------------------------ */
+
+/* abstract out the inner product computation */
+#define INPROD2(XCNR,YCNR)  \
+        { \
+        val = image[im_pos]; \
+        for (res_pos=YCNR*x_dim+XCNR, filt_pos=0, x_filt_stop=x_fdim; \
+             x_filt_stop<=filt_size; \
+             res_pos+=(x_dim-x_fdim), x_filt_stop+=x_fdim) \
+            for (; \
+                 filt_pos<x_filt_stop; \
+                 filt_pos++, res_pos++) \
+              result[res_pos] += val*temp[filt_pos]; \
+        }
+
+int internal_expand(image,filt,temp,x_fdim,y_fdim,
+                x_start,x_step,x_stop,y_start,y_step,y_stop,
+                result,x_dim,y_dim,edges)
+  register image_type *result, *temp;
+  register int x_fdim, x_dim;
+  register int x_step, y_step;
+  register image_type *image; 
+  int x_start, y_start;
+  image_type *filt; 
+  int y_fdim, y_dim;
+  char *edges;
+  {
+  register double val;
+  register int filt_pos, res_pos, x_filt_stop;
+  register int x_pos, filt_size = x_fdim*y_fdim;
+  register int y_pos, im_pos;
+  register int x_ctr_stop = x_dim - ((x_fdim==1)?0:x_fdim);
+  int y_ctr_stop = (y_dim - ((y_fdim==1)?0:y_fdim));
+  int x_ctr_start = ((x_fdim==1)?0:1);
+  int y_ctr_start = ((y_fdim==1)?0:1);
+  int x_fmid = x_fdim/2;
+  int y_fmid = y_fdim/2;
+  int base_im_pos, x_im_dim = (x_stop-x_start+x_step-1)/x_step;
+  fptr reflect = edge_function(edges);  /* look up edge-handling function */     
+
+  if (!reflect) return(-1);
+
+  /* shift start/stop coords to filter upper left hand corner */
+  x_start -= x_fmid;   y_start -=  y_fmid;
+  x_stop -=  x_fmid;   y_stop -=  y_fmid;
+
+  if (x_stop < x_ctr_stop) x_ctr_stop = x_stop;
+  if (y_stop < y_ctr_stop) y_ctr_stop = y_stop;
+
+  for (im_pos=0, y_pos=y_start;               /* TOP ROWS */
+       y_pos<y_ctr_start;
+       y_pos+=y_step)
+    {
+    for (x_pos=x_start;                       /* TOP-LEFT CORNER */
+         x_pos<x_ctr_start;
+         x_pos+=x_step, im_pos++)
+      {
+      (*reflect)(filt,x_fdim,y_fdim,x_pos-1,y_pos-1,temp,EXPAND);
+      INPROD2(0,0)
+      }
+
+    (*reflect)(filt,x_fdim,y_fdim,0,y_pos-1,temp,EXPAND);
+    for (;                                    /* TOP EDGE */
+         x_pos<x_ctr_stop;
+         x_pos+=x_step, im_pos++) 
+      INPROD2(x_pos,0)
+
+    for (;                                    /* TOP-RIGHT CORNER */
+         x_pos<x_stop;
+         x_pos+=x_step, im_pos++) 
+      {
+      (*reflect)(filt,x_fdim,y_fdim,x_pos-x_ctr_stop+1,y_pos-1,temp,EXPAND);
+      INPROD2(x_ctr_stop,0)
+      }
+    }                                           /* end TOP ROWS */   
+
+  y_ctr_start = y_pos;                        /* hold location of top */
+  for (base_im_pos=im_pos, x_pos=x_start;     /* LEFT EDGE */
+       x_pos<x_ctr_start;
+       x_pos+=x_step, base_im_pos++)
+    {
+    (*reflect)(filt,x_fdim,y_fdim,x_pos-1,0,temp,EXPAND);
+    for (y_pos=y_ctr_start, im_pos=base_im_pos;
+         y_pos<y_ctr_stop;
+         y_pos+=y_step, im_pos+=x_im_dim)
+      INPROD2(0,y_pos)
+    }
+
+  (*reflect)(filt,x_fdim,y_fdim,0,0,temp,EXPAND);
+  for (;                                      /* CENTER */
+       x_pos<x_ctr_stop;
+       x_pos+=x_step, base_im_pos++) 
+    for (y_pos=y_ctr_start, im_pos=base_im_pos;
+         y_pos<y_ctr_stop;
+         y_pos+=y_step, im_pos+=x_im_dim)
+      INPROD2(x_pos,y_pos)
+
+  for (;                                      /* RIGHT EDGE */
+       x_pos<x_stop;
+       x_pos+=x_step, base_im_pos++)
+    {
+    (*reflect)(filt,x_fdim,y_fdim,x_pos-x_ctr_stop+1,0,temp,EXPAND);
+    for (y_pos=y_ctr_start, im_pos=base_im_pos;
+         y_pos<y_ctr_stop;
+         y_pos+=y_step, im_pos+=x_im_dim)
+      INPROD2(x_ctr_stop,y_pos)
+    }  
+
+  for (im_pos-=(x_im_dim-1);
+       y_pos<y_stop;                          /* BOTTOM ROWS */
+       y_pos+=y_step) 
+    {
+    for (x_pos=x_start;                       /* BOTTOM-LEFT CORNER */
+         x_pos<x_ctr_start;
+         x_pos+=x_step, im_pos++)
+      {
+      (*reflect)(filt,x_fdim,y_fdim,x_pos-1,y_pos-y_ctr_stop+1,temp,EXPAND);
+      INPROD2(0,y_ctr_stop)
+      }
+
+    (*reflect)(filt,x_fdim,y_fdim,0,y_pos-y_ctr_stop+1,temp,EXPAND);
+    for (;                                    /* BOTTOM EDGE */
+         x_pos<x_ctr_stop;
+         x_pos+=x_step, im_pos++) 
+      INPROD2(x_pos,y_ctr_stop)
+
+    for (;                                    /* BOTTOM-RIGHT CORNER */
+         x_pos<x_stop;
+         x_pos+=x_step, im_pos++) 
+      {
+      (*reflect)(filt,x_fdim,y_fdim,x_pos-x_ctr_stop+1,y_pos-y_ctr_stop+1,temp,EXPAND);
+      INPROD2(x_ctr_stop,y_ctr_stop)
+      }
+    } /* end BOTTOM */
+  return(0);
+  } /* end of internal_expand */
+
+
+/* Local Variables: */
+/* buffer-read-only: t */
+/* End: */
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/convolve.h b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/convolve.h
new file mode 100755
index 0000000..48d55f7
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/convolve.h
@@ -0,0 +1,55 @@
+/* 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  File: convolve.h
+;;;  Author: Simoncelli
+;;;  Description: Header file for convolve.c
+;;;  Creation Date:
+;;;  ----------------------------------------------------------------
+;;;    Object-Based Vision and Image Understanding System (OBVIUS),
+;;;      Copyright 1988, Vision Science Group,  Media Laboratory,  
+;;;              Massachusetts Institute of Technology.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+*/
+
+#include <stdio.h>
+#include <stdlib.h> 
+
+#define ABS(x)    (((x)>=0) ? (x) : (-(x)))
+#define ROOT2 1.4142135623730951
+#define REDUCE 0
+#define EXPAND 1
+#define IS    ==
+#define ISNT  !=
+#define AND &&
+#define OR ||
+
+typedef  int (*fptr)();
+
+typedef struct 
+  {
+  char *name;
+  fptr func;
+  } EDGE_HANDLER;
+
+typedef double image_type;
+
+fptr edge_function(char *edges);
+int internal_reduce(image_type *image, int x_idim, int y_idim, 
+                    image_type *filt, image_type *temp, int x_fdim, int y_fdim,
+                    int x_start, int x_step, int x_stop, 
+                    int y_start, int y_step, int y_stop,
+                    image_type *result, char *edges);
+int internal_expand(image_type *image, 
+                    image_type *filt, image_type *temp, int x_fdim, int y_fdim,
+                    int x_start, int x_step, int x_stop, 
+                    int y_start, int y_step, int y_stop,
+                    image_type *result, int x_rdim, int y_rdim, char *edges);
+int internal_wrap_reduce(image_type *image, int x_idim, int y_idim, 
+                         image_type *filt, int x_fdim, int y_fdim,
+                         int x_start, int x_step, int x_stop, 
+                         int y_start, int y_step, int y_stop,
+                         image_type *result);
+int internal_wrap_expand(image_type *image, image_type *filt, int x_fdim, int y_fdim,
+                         int x_start, int x_step, int x_stop, 
+                         int y_start, int y_step, int y_stop,
+                         image_type *result, int x_rdim, int y_rdim);
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/convolve.mexglx b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/convolve.mexglx
new file mode 100755
index 0000000..2dea157
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/convolve.mexglx
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/corrDn.c b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/corrDn.c
new file mode 100755
index 0000000..c74df1f
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/corrDn.c
@@ -0,0 +1,145 @@
+/* 
+RES = corrDn(IM, FILT, EDGES, STEP, START, STOP);
+  >>> See corrDn.m for documentation <<<
+  This is a matlab interface to the internal_reduce function. 
+  EPS, 7/96.
+*/
+
+#define V4_COMPAT
+#include <matrix.h>  /* Matlab matrices */
+#include <mex.h>
+
+#include "convolve.h"
+
+#define notDblMtx(it) (!mxIsNumeric(it) || !mxIsDouble(it) || mxIsSparse(it) || mxIsComplex(it))
+
+void mexFunction(int nlhs,           /* Num return vals on lhs */
+                 mxArray *plhs[],    /* Matrices on lhs      */
+                 int nrhs,           /* Num args on rhs    */
+                 const mxArray *prhs[]     /* Matrices on rhs */
+                 )
+  {
+  double *image,*filt, *temp, *result;
+  int x_fdim, y_fdim, x_idim, y_idim;
+  int x_rdim, y_rdim;
+  int x_start = 1;
+  int x_step = 1;
+  int y_start = 1;
+  int y_step = 1;
+  int x_stop, y_stop;
+  mxArray *arg;
+  double *mxMat;
+  char edges[15] = "reflect1";
+  
+  if (nrhs<2) mexErrMsgTxt("requres at least 2 args.");
+
+  /* ARG 1: IMAGE  */
+  arg = prhs[0];
+  if notDblMtx(arg) mexErrMsgTxt("IMAGE arg must be a non-sparse double float matrix.");
+  image = mxGetPr(arg);
+  x_idim = (int) mxGetM(arg); /* X is inner index! */
+  y_idim = (int) mxGetN(arg);
+
+  /* ARG 2: FILTER */
+  arg = prhs[1];
+  if notDblMtx(arg) mexErrMsgTxt("FILTER arg must be non-sparse double float matrix.");
+  filt = mxGetPr(arg);
+  x_fdim = (int) mxGetM(arg); 
+  y_fdim = (int) mxGetN(arg);
+
+  if ((x_fdim > x_idim) || (y_fdim > y_idim))
+    {
+    mexPrintf("Filter: [%d %d], Image: [%d %d]\n",x_fdim,y_fdim,x_idim,y_idim);
+    mexErrMsgTxt("FILTER dimensions larger than IMAGE dimensions.");
+    }
+
+  /* ARG 3 (optional): EDGES */
+  if (nrhs>2) 
+      {
+      if (!mxIsChar(prhs[2]))
+        mexErrMsgTxt("EDGES arg must be a string.");
+      mxGetString(prhs[2],edges,15);
+      }
+
+  /* ARG 4 (optional): STEP */
+  if (nrhs>3)
+      {
+      arg = prhs[3];
+      if notDblMtx(arg) mexErrMsgTxt("STEP arg must be a double float matrix.");
+      if (mxGetM(arg) * mxGetN(arg) != 2)
+         mexErrMsgTxt("STEP arg must contain two elements.");
+      mxMat = mxGetPr(arg);
+      x_step = (int) mxMat[0];
+      y_step = (int) mxMat[1];
+      if ((x_step<1) || (y_step<1))
+         mexErrMsgTxt("STEP values must be greater than zero.");
+      }
+
+  /* ARG 5 (optional): START */
+  if (nrhs>4)
+      {
+      arg = prhs[4];
+      if notDblMtx(arg) mexErrMsgTxt("START arg must be a double float matrix.");
+      if (mxGetM(arg) * mxGetN(arg) != 2)
+        mexErrMsgTxt("START arg must contain two elements.");
+      mxMat = mxGetPr(arg);
+      x_start = (int) mxMat[0];
+      y_start = (int) mxMat[1];
+      if ((x_start<1) || (x_start>x_idim) ||
+          (y_start<1) || (y_start>y_idim))
+         mexErrMsgTxt("START values must lie between 1 and the image dimensions.");
+      }
+  x_start--;  /* convert from Matlab to standard C indexes */
+  y_start--;
+
+  /* ARG 6 (optional): STOP */
+  if (nrhs>5)
+      {
+      if notDblMtx(prhs[5]) mexErrMsgTxt("STOP arg must be double float matrix.");
+      if (mxGetM(prhs[5]) * mxGetN(prhs[5]) != 2)
+         mexErrMsgTxt("STOP arg must contain two elements.");
+      mxMat = mxGetPr(prhs[5]);
+      x_stop = (int) mxMat[0];
+      y_stop = (int) mxMat[1];
+      if ((x_stop<x_start) || (x_stop>x_idim) ||
+          (y_stop<y_start) || (y_stop>y_idim))
+         mexErrMsgTxt("STOP values must lie between START and the image dimensions.");
+      }
+  else
+      {
+      x_stop = x_idim;
+      y_stop = y_idim;
+      }
+          
+  x_rdim = (x_stop-x_start+x_step-1) / x_step;
+  y_rdim = (y_stop-y_start+y_step-1) / y_step;
+  
+  /*  mxFreeMatrix(plhs[0]); */
+  plhs[0] = (mxArray *) mxCreateDoubleMatrix(x_rdim,y_rdim,mxREAL);
+  if (plhs[0] == NULL) mexErrMsgTxt("Cannot allocate result matrix");
+  result = mxGetPr(plhs[0]);
+
+  temp = mxCalloc(x_fdim*y_fdim, sizeof(double));
+  if (temp == NULL)
+    mexErrMsgTxt("Cannot allocate necessary temporary space");
+
+  /*
+    printf("i(%d, %d), f(%d, %d), r(%d, %d), X(%d, %d, %d), Y(%d, %d, %d), %s\n",
+         x_idim,y_idim,x_fdim,y_fdim,x_rdim,y_rdim,
+         x_start,x_step,x_stop,y_start,y_step,y_stop,edges);
+         */
+
+  if (strcmp(edges,"circular") == 0)
+        internal_wrap_reduce(image, x_idim, y_idim, filt, x_fdim, y_fdim,
+                             x_start, x_step, x_stop, y_start, y_step, y_stop,
+                             result);
+  else internal_reduce(image, x_idim, y_idim, filt, temp, x_fdim, y_fdim,
+                       x_start, x_step, x_stop, y_start, y_step, y_stop,
+                       result, edges);
+
+  mxFree((char *) temp);
+  return;
+  } 
+
+
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/edges.c b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/edges.c
new file mode 100755
index 0000000..98b377d
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/edges.c
@@ -0,0 +1,647 @@
+/* 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  File: edges.c
+;;;  Author: Eero Simoncelli
+;;;  Description: Boundary handling routines for use with convolve.c
+;;;  Creation Date: Spring 1987.
+;;;  MODIFIED, 6/96, to operate on double float arrays.
+;;;  MODIFIED by dgp, 4/1/97, to support THINK C.
+;;;  MODIFIED, 8/97: reflect1, reflect2, repeat, extend upgraded to 
+;;;       work properly for non-symmetric filters.  Added qreflect2 to handle
+;;;       even-length QMF's which broke under the reflect2 modification.
+;;;  ----------------------------------------------------------------
+;;;    Object-Based Vision and Image Understanding System (OBVIUS),
+;;;      Copyright 1988, Vision Science Group,  Media Laboratory,  
+;;;              Massachusetts Institute of Technology.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+*/
+
+/* This file contains functions which determine how edges are to be
+handled when performing convolutions of images with linear filters.
+Any edge handling function which is local and linear may be defined,
+except (unfortunately) constants cannot be added.  So to treat the
+edges as if the image is surrounded by a gray field, you must paste it
+into a gray image, convolve, and crop it out...  The main convolution
+functions are called internal_reduce and internal_expand and are
+defined in the file convolve.c.  The idea is that the convolution
+function calls the edge handling function which computes a new filter
+based on the old filter and the distance to the edge of the image.
+For example, reflection is done by reflecting the filter through the
+appropriate axis and summing.  Currently defined functions are listed
+below.
+*/
+
+
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+#include "convolve.h"
+
+#define sgn(a)  ( ((a)>0)?1:(((a)<0)?-1:0) )
+#define clip(a,mn,mx)  ( ((a)<(mn))?(mn):(((a)>=(mx))?(mx-1):(a)) )
+
+int reflect1(), reflect2(), qreflect2(), repeat(), zero(), Extend(), nocompute();
+int ereflect(), predict();
+
+/* Lookup table matching a descriptive string to the edge-handling function */
+#if !THINK_C
+        static EDGE_HANDLER edge_foos[] =
+          {
+            { "dont-compute", nocompute }, /* zero output for filter touching edge */
+            { "zero",     zero     },   /* zero outside of image */
+            { "repeat",   repeat   },   /* repeat edge pixel */
+            { "reflect1", reflect1 },   /* reflect about edge pixels  */
+            { "reflect2", reflect2 },   /* reflect image, including edge pixels  */
+            { "qreflect2", qreflect2 },   /* reflect image, including edge pixels
+                                             for even-length QMF decompositions */
+            { "extend",   Extend   },   /* extend (reflect & invert) */
+            { "ereflect", ereflect },   /* orthogonal QMF reflection */
+          };
+#else
+        /*
+        This is really stupid, but THINK C won't allow initialization of static variables in
+        a code resource with string addresses. So we do it this way.
+        The 68K code for a MATLAB 4 MEX file can only be created by THINK C.
+        However, for MATLAB 5, we'll be able to use Metrowerks CodeWarrior for both 68K and PPC, so this
+        cludge can be dropped when we drop support for MATLAB 4.
+        Denis Pelli, 4/1/97. 
+        */
+        static EDGE_HANDLER edge_foos[8];
+
+        void InitializeTable(EDGE_HANDLER edge_foos[])
+        {
+                static int i=0;
+                
+                if(i>0) return;
+                edge_foos[i].name="dont-compute";
+                edge_foos[i++].func=nocompute;
+                edge_foos[i].name="zero";
+                edge_foos[i++].func=zero;
+                edge_foos[i].name="repeat";
+                edge_foos[i++].func=repeat;
+                edge_foos[i].name="reflect1";
+                edge_foos[i++].func=reflect1;
+                edge_foos[i].name="reflect2";
+                edge_foos[i++].func=reflect2;
+                edge_foos[i].name="qreflect2";
+                edge_foos[i++].func=qreflect2;
+                edge_foos[i].name="extend";
+                edge_foos[i++].func=Extend;
+                edge_foos[i].name="ereflect";
+                edge_foos[i++].func=ereflect;
+        }
+#endif
+
+/*
+Function looks up an edge handler id string in the structure above, and
+returns the associated function 
+*/
+fptr edge_function(char *edges)
+  {
+  int i;
+
+#if THINK_C
+  InitializeTable(edge_foos);
+#endif
+  for (i = 0; i<sizeof(edge_foos)/sizeof(EDGE_HANDLER); i++)
+    if (strcmp(edges,edge_foos[i].name) IS 0)
+      return(edge_foos[i].func);
+  printf("Error: '%s' is not the name of a valid edge-handler!\n",edges);
+  for (i=0; i<sizeof(edge_foos)/sizeof(EDGE_HANDLER); i++)
+      {
+      if (i IS 0) printf("  Options are: ");
+      else printf(", ");
+      printf("%s",edge_foos[i].name);
+      }
+  printf("\n");
+  return(0);
+  }
+
+/* 
+---------------- EDGE HANDLER ARGUMENTS ------------------------
+filt - array of filter taps.
+x_dim, y_dim - x and y dimensions of filt.
+x_pos - position of filter relative to the horizontal image edges. Negative
+       values indicate left edge, positive indicate right edge.  Zero 
+       indicates that the filter is not touching either edge.  An absolute
+       value of 1 indicates that the edge tap of the filter is over the 
+       edge pixel of the image.
+y_pos - analogous to x_pos.
+result - array where the resulting filter will go.  The edge
+       of this filter will be aligned with the image for application...
+r_or_e - equal to one of the two constants EXPAND or REDUCE.
+-------------------------------------------------------------------- 
+*/ 
+
+
+/* --------------------------------------------------------------------
+nocompute() - Return zero for values where filter hangs over the edge.
+*/
+
+int nocompute(filt,x_dim,y_dim,x_pos,y_pos,result,r_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, r_or_e;
+  {
+  register int i;
+  register int size = x_dim*y_dim;
+
+  if ( (x_pos>1) OR (x_pos<-1) OR (y_pos>1) OR (y_pos<-1) )
+    for (i=0; i<size; i++)  result[i] = 0.0;
+  else
+    for (i=0; i<size; i++)  result[i] = filt[i];
+
+  return(0);
+  }
+
+/* --------------------------------------------------------------------
+zero() - Zero outside of image.  Discontinuous, but adds zero energy. */
+
+int zero(filt,x_dim,y_dim,x_pos,y_pos,result,r_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, r_or_e;
+  {
+  register int y_filt,x_filt, y_res,x_res;
+  int filt_sz = x_dim*y_dim;
+  int x_start = ((x_pos>0)?(x_pos-1):((x_pos<0)?(x_pos+1):0));
+  int y_start = x_dim * ((y_pos>0)?(y_pos-1):((y_pos<0)?(y_pos+1):0));
+  int i;
+
+  for (i=0; i<filt_sz; i++) result[i] = 0.0;
+
+  for (y_filt=0, y_res=y_start;
+       y_filt<filt_sz;
+       y_filt+=x_dim, y_res+=x_dim)
+    if ((y_res >= 0) AND (y_res < filt_sz))
+      for (x_filt=y_filt, x_res=x_start;
+           x_filt<y_filt+x_dim;
+           x_filt++, x_res++)
+        if ((x_res >= 0) AND (x_res < x_dim))
+          result[y_res+x_res] = filt[x_filt];
+  return(0);
+  }
+
+
+/* --------------------------------------------------------------------
+reflect1() - Reflection through the edge pixels.  Continuous, but
+discontinuous first derivative.  This is the right thing to do if you
+are subsampling by 2, since it maintains parity (even pixels positions
+remain even, odd ones remain odd).
+*/       
+
+int reflect1(filt,x_dim,y_dim,x_pos,y_pos,result,r_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, r_or_e;
+  {
+  int filt_sz = x_dim*y_dim;
+  register int y_filt,x_filt, y_res, x_res;
+  register int x_base = (x_pos>0)?(x_dim-1):0;
+  register int y_base = x_dim * ((y_pos>0)?(y_dim-1):0); 
+  int x_overhang = (x_pos>0)?(x_pos-1):((x_pos<0)?(x_pos+1):0);
+  int y_overhang = x_dim * ((y_pos>0)?(y_pos-1):((y_pos<0)?(y_pos+1):0));
+  int i;
+  int mx_pos = (x_pos<0)?(x_dim/2):((x_dim-1)/2);
+  int my_pos = x_dim * ((y_pos<0)?(y_dim/2):((y_dim-1)/2));
+
+  for (i=0; i<filt_sz; i++) result[i] = 0.0;
+
+  if (r_or_e IS REDUCE)
+    for (y_filt=0, y_res=y_overhang-y_base;
+         y_filt<filt_sz;
+         y_filt+=x_dim, y_res+=x_dim)
+      for (x_filt=y_filt, x_res=x_overhang-x_base;
+           x_filt<y_filt+x_dim;
+           x_filt++, x_res++)
+        result[ABS(y_base-ABS(y_res)) + ABS(x_base-ABS(x_res))]
+          += filt[x_filt];
+  else {
+      y_overhang = ABS(y_overhang); 
+      x_overhang = ABS(x_overhang);
+      for (y_res=y_base, y_filt = y_base-y_overhang;
+           y_filt > y_base-filt_sz;
+           y_filt-=x_dim, y_res-=x_dim)
+          {
+          for (x_res=x_base, x_filt=x_base-x_overhang;
+               x_filt > x_base-x_dim;
+               x_res--, x_filt--)
+            result[ABS(y_res)+ABS(x_res)] += filt[ABS(y_filt)+ABS(x_filt)];
+          if ((x_overhang ISNT mx_pos) AND (x_pos ISNT 0))
+            for (x_res=x_base, x_filt=x_base-2*mx_pos+x_overhang;
+                 x_filt > x_base-x_dim;
+                 x_res--, x_filt--)
+              result[ABS(y_res)+ABS(x_res)] += filt[ABS(y_filt)+ABS(x_filt)];
+          }
+      if ((y_overhang ISNT my_pos) AND (y_pos ISNT 0))
+        for (y_res=y_base, y_filt = y_base-2*my_pos+y_overhang;
+             y_filt > y_base-filt_sz;
+             y_filt-=x_dim, y_res-=x_dim)
+            {
+            for (x_res=x_base, x_filt=x_base-x_overhang;
+                 x_filt > x_base-x_dim;
+                 x_res--, x_filt--)
+              result[ABS(y_res)+ABS(x_res)] += filt[ABS(y_filt)+ABS(x_filt)];
+            if  ((x_overhang ISNT mx_pos) AND (x_pos ISNT 0))
+              for (x_res=x_base, x_filt=x_base-2*mx_pos+x_overhang;
+                   x_filt > x_base-x_dim;
+                   x_res--, x_filt--)
+                result[ABS(y_res)+ABS(x_res)] += filt[ABS(y_filt)+ABS(x_filt)];
+            }
+      }
+
+  return(0);
+  }
+
+/* --------------------------------------------------------------------
+reflect2() - Reflect image at boundary.  The edge pixel is repeated,
+then the next pixel, etc.  Continuous, but discontinuous first
+derivative.
+*/
+
+int reflect2(filt,x_dim,y_dim,x_pos,y_pos,result,r_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, r_or_e;
+  {
+  int filt_sz = x_dim*y_dim;
+  register int y_filt,x_filt, y_res, x_res;
+  register int x_base = (x_pos>0)?(x_dim-1):0;
+  register int y_base = x_dim * ((y_pos>0)?(y_dim-1):0); 
+  int x_overhang = (x_pos>0)?(x_pos-1):((x_pos<0)?(x_pos+1):0);
+  int y_overhang = x_dim * ((y_pos>0)?(y_pos-1):((y_pos<0)?(y_pos+1):0));
+  int i;
+  int mx_pos = (x_pos<0)?(x_dim/2):((x_dim-1)/2);
+  int my_pos = x_dim * ((y_pos<0)?(y_dim/2):((y_dim-1)/2));
+
+  for (i=0; i<filt_sz; i++) result[i] = 0.0;
+
+  if (r_or_e IS REDUCE)
+    for (y_filt=0, y_res = (y_overhang-y_base) - ((y_pos>0)?x_dim:0);
+         y_filt<filt_sz;
+         y_filt+=x_dim, y_res+=x_dim)
+        {
+        if (y_res IS 0) y_res+=x_dim;
+        for (x_filt=y_filt, x_res = (x_overhang-x_base) - ((x_pos>0)?1:0);
+             x_filt<y_filt+x_dim;
+             x_filt++, x_res++)
+            {
+            if (x_res IS 0) x_res++;
+            result[ABS(y_base-ABS(y_res)+x_dim) + ABS(x_base-ABS(x_res)+1)]
+              += filt[x_filt];
+            }
+        }
+  else {
+      y_overhang = ABS(y_overhang); 
+      x_overhang = ABS(x_overhang);
+      for (y_res=y_base, y_filt = y_base-y_overhang;
+           y_filt > y_base-filt_sz;
+           y_filt-=x_dim, y_res-=x_dim)
+          {
+          for (x_res=x_base, x_filt=x_base-x_overhang;
+               x_filt > x_base-x_dim;
+               x_res--, x_filt--)
+            result[ABS(y_res)+ABS(x_res)] += filt[ABS(y_filt)+ABS(x_filt)];
+          if (x_pos ISNT 0)
+            for (x_res=x_base, x_filt=x_base-2*mx_pos+x_overhang-1;
+                 x_filt > x_base-x_dim;
+                 x_res--, x_filt--)
+              result[ABS(y_res)+ABS(x_res)] += filt[ABS(y_filt)+ABS(x_filt)];
+          }
+       if (y_pos ISNT 0)
+         for (y_res=y_base, y_filt = y_base-2*my_pos+y_overhang-x_dim;
+              y_filt > y_base-filt_sz;
+              y_filt-=x_dim, y_res-=x_dim)
+             {
+             for (x_res=x_base, x_filt=x_base-x_overhang;
+                  x_filt > x_base-x_dim;
+                  x_res--, x_filt--)
+               result[ABS(y_res)+ABS(x_res)] += filt[ABS(y_filt)+ABS(x_filt)];
+             if (x_pos ISNT 0)
+               for (x_res=x_base, x_filt=x_base-2*mx_pos+x_overhang-1;
+                    x_filt > x_base-x_dim;
+                    x_res--, x_filt--)
+                 result[ABS(y_res)+ABS(x_res)] += filt[ABS(y_filt)+ABS(x_filt)];
+             }
+      }
+
+  return(0);
+  }
+
+
+/* --------------------------------------------------------------------
+qreflect2() - Modified version of reflect2 that  works properly for 
+even-length QMF filters.
+*/
+
+int qreflect2(filt,x_dim,y_dim,x_pos,y_pos,result,r_or_e)
+  double *filt, *result;
+  int x_dim, y_dim, x_pos, y_pos, r_or_e;
+  {
+  reflect2(filt,x_dim,y_dim,x_pos,y_pos,result,0);
+  return(0);
+  }
+
+/* --------------------------------------------------------------------
+repeat() - repeat edge pixel.  Continuous, with discontinuous first
+derivative.
+*/
+
+int repeat(filt,x_dim,y_dim,x_pos,y_pos,result,r_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, r_or_e;
+  {
+  register int y_filt,x_filt, y_res,x_res, y_tmp, x_tmp;
+  register int x_base = (x_pos>0)?(x_dim-1):0;
+  register int y_base = x_dim * ((y_pos>0)?(y_dim-1):0); 
+  int x_overhang = ((x_pos>0)?(x_pos-1):((x_pos<0)?(x_pos+1):0));
+  int y_overhang = x_dim * ((y_pos>0)?(y_pos-1):((y_pos<0)?(y_pos+1):0));
+  int filt_sz = x_dim*y_dim;
+  int mx_pos = (x_dim/2);
+  int my_pos = x_dim * (y_dim/2);
+  int i;
+
+  for (i=0; i<filt_sz; i++) result[i] = 0.0;
+
+  if (r_or_e IS REDUCE)
+    for (y_filt=0, y_res=y_overhang;
+         y_filt<filt_sz;
+         y_filt+=x_dim, y_res+=x_dim)
+      for (x_filt=y_filt, x_res=x_overhang;
+           x_filt<y_filt+x_dim;
+           x_filt++, x_res++)
+        /* Clip the index: */
+        result[((y_res>=0)?((y_res<filt_sz)?y_res:(filt_sz-x_dim)):0) 
+               + ((x_res>=0)?((x_res<x_dim)?x_res:(x_dim-1)):0)]      
+                 += filt[x_filt];
+  else {
+    if ((y_base-y_overhang) ISNT my_pos)
+      for (y_res=y_base, y_filt=y_base-ABS(y_overhang);
+           y_filt > y_base-filt_sz;
+           y_filt-=x_dim, y_res-=x_dim)
+        if ((x_base-x_overhang) ISNT mx_pos)
+          for (x_res=x_base, x_filt=x_base-ABS(x_overhang);
+               x_filt > x_base-x_dim;
+               x_res--, x_filt--)
+            result[ABS(y_res)+ABS(x_res)] += filt[ABS(y_filt)+ABS(x_filt)];
+        else  /* ((x_base-x_overhang) IS mx_pos) */
+          for (x_res=x_base, x_filt=x_base-ABS(x_overhang);
+               x_filt > x_base-x_dim;
+               x_filt--, x_res--)
+            for(x_tmp=x_filt; x_tmp > x_base-x_dim; x_tmp--)
+              result[ABS(y_res)+ABS(x_res)] += filt[ABS(y_filt)+ABS(x_tmp)];
+    else /* ((y_base-y_overhang) IS my_pos) */
+      for (y_res=y_base, y_filt=y_base-ABS(y_overhang);
+           y_filt > y_base-filt_sz;
+           y_filt-=x_dim, y_res-=x_dim)
+        for (y_tmp=y_filt; y_tmp > y_base-filt_sz; y_tmp-=x_dim)
+          if  ((x_base-x_overhang) ISNT mx_pos)
+            for (x_res=x_base, x_filt=x_base-ABS(x_overhang);
+                 x_filt > x_base-x_dim;
+                 x_filt--, x_res--)
+              result[ABS(y_res)+ABS(x_res)] += filt[ABS(y_tmp)+ABS(x_filt)];
+          else /* ((x_base-x_overhang) IS mx_pos) */
+            for (x_res=x_base, x_filt=x_base-ABS(x_overhang);
+                 x_filt > x_base-x_dim;
+                 x_filt--, x_res--)
+              for (x_tmp=x_filt; x_tmp > x_base-x_dim; x_tmp--)
+                result[ABS(y_res)+ABS(x_res)] += filt[ABS(y_tmp)+ABS(x_tmp)];
+    } /* End, if r_or_e IS EXPAND */
+
+  return(0);
+  }
+
+/* --------------------------------------------------------------------
+extend() - Extend image by reflecting and inverting about edge pixel
+value.  Maintains continuity in intensity AND first derivative (but
+not higher derivs).
+*/
+
+int Extend(filt,x_dim,y_dim,x_pos,y_pos,result,r_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, r_or_e;
+  {
+  int filt_sz = x_dim*y_dim;
+  register int y_filt,x_filt, y_res,x_res, y_tmp, x_tmp;
+  register int x_base = (x_pos>0)?(x_dim-1):0;
+  register int y_base = x_dim * ((y_pos>0)?(y_dim-1):0); 
+  int x_overhang = (x_pos>0)?(x_pos-1):((x_pos<0)?(x_pos+1):0);
+  int y_overhang = x_dim * ((y_pos>0)?(y_pos-1):((y_pos<0)?(y_pos+1):0));
+  int mx_pos = (x_pos<0)?(x_dim/2):((x_dim-1)/2);
+  int my_pos = x_dim * ((y_pos<0)?(y_dim/2):((y_dim-1)/2));
+  int i;
+
+  for (i=0; i<filt_sz; i++) result[i] = 0.0;
+
+  /* Modeled on reflect1() */
+  if (r_or_e IS REDUCE)
+    for (y_filt=0, y_res=y_overhang;
+         y_filt<filt_sz;
+         y_filt+=x_dim, y_res+=x_dim)
+      if ((y_res>=0) AND (y_res<filt_sz))
+        for (x_filt=y_filt, x_res=x_overhang;
+             x_filt<y_filt+x_dim;
+             x_filt++, x_res++)
+          if ((x_res>=0) AND (x_res<x_dim))
+            result[y_res+x_res] += filt[x_filt];
+          else
+              {
+              result[y_res+ABS(x_base-ABS(x_res-x_base))] -= filt[x_filt];
+              result[y_res+x_base] += 2*filt[x_filt];
+              }
+      else
+        for (x_filt=y_filt, x_res=x_overhang;
+             x_filt<y_filt+x_dim;
+             x_filt++, x_res++)
+          if ((x_res>=0) AND (x_res<x_dim))
+              {
+              result[ABS(y_base-ABS(y_res-y_base))+x_res] -= filt[x_filt];
+              result[y_base+x_res] += 2*filt[x_filt];
+              }
+          else
+              {
+              result[ABS(y_base-ABS(y_res-y_base))+ABS(x_base-ABS(x_res-x_base))] 
+                -= filt[x_filt];
+              result[y_base+x_base] += 2*filt[x_filt];
+              }
+  else {  /* r_or_e ISNT  REDUCE */
+      y_overhang = ABS(y_overhang); 
+      x_overhang = ABS(x_overhang);
+      for (y_res=y_base, y_filt = y_base-y_overhang;
+           y_filt > y_base-filt_sz;
+           y_filt-=x_dim, y_res-=x_dim)
+          {
+          for (x_res=x_base, x_filt=x_base-x_overhang;
+               x_filt > x_base-x_dim;
+               x_res--, x_filt--)
+            result[ABS(y_res)+ABS(x_res)] += filt[ABS(y_filt)+ABS(x_filt)];
+          if (x_pos ISNT 0)
+            if (x_overhang ISNT mx_pos)
+              for (x_res=x_base, x_filt=x_base-2*mx_pos+x_overhang;
+                   x_filt > x_base-x_dim;
+                   x_res--, x_filt--)
+                result[ABS(y_res)+ABS(x_res)] -= filt[ABS(y_filt)+ABS(x_filt)];
+            else /* x_overhang IS mx_pos */
+              for (x_res=x_base, x_filt=x_base-2*mx_pos+x_overhang-1;
+                   x_filt > x_base-x_dim;
+                   x_res--, x_filt--)
+                for (x_tmp=x_filt; x_tmp > x_base-x_dim; x_tmp--)
+                  result[ABS(y_res)+ABS(x_res)] += 2*filt[ABS(y_filt)+ABS(x_tmp)];
+          }
+       if (y_pos ISNT 0)
+         if (y_overhang ISNT my_pos)
+           for (y_res=y_base, y_filt = y_base-2*my_pos+y_overhang;
+                y_filt > y_base-filt_sz;
+                y_filt-=x_dim, y_res-=x_dim)
+               {
+               for (x_res=x_base, x_filt=x_base-x_overhang;
+                    x_filt > x_base-x_dim;
+                    x_res--, x_filt--)
+                 result[ABS(y_res)+ABS(x_res)] -= filt[ABS(y_filt)+ABS(x_filt)];
+               if ((x_pos ISNT 0) AND (x_overhang ISNT mx_pos))
+                 for (x_res=x_base, x_filt=x_base-2*mx_pos+x_overhang;
+                      x_filt > x_base-x_dim;
+                      x_res--, x_filt--)
+                   result[ABS(y_res)+ABS(x_res)] -= filt[ABS(y_filt)+ABS(x_filt)];
+               }
+         else /* y_overhang IS my_pos */
+           for (y_res=y_base, y_filt = y_base-2*my_pos+y_overhang-x_dim;
+                y_filt > y_base-filt_sz;
+                y_res-=x_dim, y_filt-=x_dim)
+             for (y_tmp=y_filt; y_tmp > y_base-filt_sz; y_tmp-=x_dim)
+                 {
+                 for (x_res=x_base, x_filt=x_base-x_overhang;
+                      x_filt > x_base-x_dim;
+                      x_res--, x_filt--)
+                   result[ABS(y_res)+ABS(x_res)] += 2*filt[ABS(y_tmp)+ABS(x_filt)];
+                 if ((x_pos ISNT 0) AND (x_overhang IS mx_pos))
+                   for (x_res=x_base, x_filt=x_base-2*mx_pos+x_overhang-1;
+                        x_filt > x_base-x_dim;
+                        x_res--, x_filt--)
+                     for (x_tmp=x_filt; x_tmp > x_base-x_dim; x_tmp--)
+                       result[ABS(y_res)+ABS(x_res)] += 2*filt[ABS(y_tmp)+ABS(x_tmp)];
+                 }
+      }  /* r_or_e ISNT  REDUCE */
+
+  return(0);
+  }
+
+/* --------------------------------------------------------------------
+predict() - Simple prediction.  Like zero, but multiplies the result
+by the reciprocal of the percentage of filter being used.  (i.e. if
+50% of the filter is hanging over the edge of the image, multiply the
+taps being used by 2).  */
+
+int predict(filt,x_dim,y_dim,x_pos,y_pos,result,r_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, r_or_e;
+  {
+  register int y_filt,x_filt, y_res,x_res;
+  register double taps_used = 0.0; /* int *** */
+  register double fraction = 0.0;
+  int filt_sz = x_dim*y_dim;
+  int x_start = ((x_pos>0)?(x_pos-1):((x_pos<0)?(x_pos+1):0));
+  int y_start = x_dim * ((y_pos>0)?(y_pos-1):((y_pos<0)?(y_pos+1):0));
+  int i;
+
+  for (i=0; i<filt_sz; i++) result[i] = 0.0;
+
+  for (y_filt=0, y_res=y_start;
+       y_filt<filt_sz;
+       y_filt+=x_dim, y_res+=x_dim)
+    if ((y_res >= 0) AND (y_res < filt_sz))
+      for (x_filt=y_filt, x_res=x_start;
+           x_filt<y_filt+x_dim;
+           x_filt++, x_res++)
+        if ((x_res >= 0) AND (x_res < x_dim))
+          {
+            result[y_res+x_res] = filt[x_filt];
+            taps_used += ABS(filt[x_filt]);
+          }
+
+  if (r_or_e IS REDUCE)
+      {
+      /* fraction = ( (double) filt_sz ) / ( (double) taps_used ); */
+      for (i=0; i<filt_sz; i++) fraction += ABS(filt[i]);
+      fraction = ( fraction / taps_used );
+      for (i=0; i<filt_sz; i++) result[i] *= fraction;
+      }
+  return(0);
+  }
+
+
+/* --------------------------------------------------------------------
+Reflect, multiplying tap of filter which is at the edge of the image
+by root 2.  This maintains orthogonality of odd-length linear-phase
+QMF filters, but it is not useful for most applications, since it
+alters the DC level.  */
+
+int ereflect(filt,x_dim,y_dim,x_pos,y_pos,result,r_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, r_or_e;
+  {
+  register int y_filt,x_filt, y_res,x_res;
+  register int x_base = (x_pos>0)?(x_dim-1):0;
+  register int y_base = x_dim * ((y_pos>0)?(y_dim-1):0); 
+  int filt_sz = x_dim*y_dim;
+  int x_overhang = (x_pos>1)?(x_pos-x_dim):((x_pos<-1)?(x_pos+1):0);
+  int y_overhang = x_dim * ( (y_pos>1)?(y_pos-y_dim):((y_pos<-1)?(y_pos+1):0) );
+  int i;
+  double norm,onorm;
+
+  for (i=0; i<filt_sz; i++) result[i] = 0.0;
+
+  /* reflect at boundary */       
+  for (y_filt=0, y_res=y_overhang;
+       y_filt<filt_sz;
+       y_filt+=x_dim, y_res+=x_dim)
+    for (x_filt=y_filt, x_res=x_overhang;
+         x_filt<y_filt+x_dim;
+         x_filt++, x_res++)
+      result[ABS(y_base-ABS(y_res)) + ABS(x_base-ABS(x_res))]
+        += filt[x_filt];
+
+  /* now multiply edge by root 2 */
+  if (x_pos ISNT 0) 
+    for (y_filt=x_base; y_filt<filt_sz; y_filt+=x_dim)
+      result[y_filt] *= ROOT2;
+  if (y_pos ISNT 0) 
+    for (x_filt=y_base; x_filt<y_base+x_dim; x_filt++)
+      result[x_filt] *= ROOT2;
+
+  /* now normalize to norm of original filter */
+  for (norm=0.0,i=0; i<filt_sz; i++)
+    norm += (result[i]*result[i]);
+  norm=sqrt(norm);
+
+  for (onorm=0.0,i=0; i<filt_sz; i++)
+    onorm += (filt[i]*filt[i]);
+  onorm = sqrt(onorm);
+
+  norm = norm/onorm;
+  for (i=0; i<filt_sz; i++)
+    result[i] /= norm;
+  return(0);
+  }
+
+
+/* ------- printout stuff for testing ------------------------------
+  printf("Xpos: %d, Ypos: %d", x_pos, y_pos);
+    for (y_filt=0; y_filt<y_dim; y_filt++)
+      {
+      printf("\n");
+      for (x_filt=0; x_filt<x_dim; x_filt++)
+        printf("%6.1f", result[y_filt*x_dim+x_filt]);
+      }
+  printf("\n");
+*/
+
+
+
+/* Local Variables: */
+/* buffer-read-only: t */
+/* End: */
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/edges.mexa64 b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/edges.mexa64
new file mode 100755
index 0000000..4839d1e
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/edges.mexa64
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/histo.c b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/histo.c
new file mode 100755
index 0000000..43a99c7
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/histo.c
@@ -0,0 +1,140 @@
+/* 
+[N, X] = histo(MTX, NBINS_OR_BINSIZE, BIN_CENTER)
+  >>> See histo.m for documentation <<<
+  EPS, ported from OBVIUS, 3/97.
+*/
+
+#define V4_COMPAT
+#include <matrix.h>  /* Matlab matrices */
+#include <mex.h>
+
+#include <stddef.h>  /* NULL */
+#include <math.h>  /* ceil */
+
+#define notDblMtx(it) (!mxIsNumeric(it) || !mxIsDouble(it) || mxIsSparse(it) || mxIsComplex(it))
+
+#define PAD 0.49999 /* A hair below 1/2, to avoid roundoff errors */
+#define MAXBINS 20000
+
+void mexFunction(int nlhs,           /* Num return vals on lhs */
+                 mxArray *plhs[],    /* Matrices on lhs      */
+                 int nrhs,           /* Num args on rhs    */
+                 const mxArray *prhs[]     /* Matrices on rhs */
+                 )
+  {
+  register double temp;
+  register int binnum, i, size;
+  register double *im, binsize;
+  register double origin, *hist, mn, mx, mean;
+  register int nbins;
+  double *bincenters; 
+  mxArray *arg;
+  double *mxMat;
+
+  if (nrhs < 1 ) mexErrMsgTxt("requires at least 1 argument.");
+
+  /* ARG 1: MATRIX  */
+  arg = prhs[0];
+  if notDblMtx(arg) mexErrMsgTxt("MTX arg must be a real non-sparse matrix.");
+  im = mxGetPr(arg);
+  size = (int) mxGetM(arg) * mxGetN(arg);
+
+  /* FIND min, max, mean values of MTX */
+  mn = *im;   mx = *im;  binsize = 0;
+  for (i=1; i<size; i++)
+    {
+      temp = im[i];
+      if (temp < mn)
+        mn = temp;
+      else if (temp > mx)
+        mx = temp;
+      binsize += temp;
+    }
+  mean = binsize / size;
+
+  /* ARG 3: BIN_CENTER */
+  if (nrhs > 2)
+    {
+    arg = prhs[2];
+    if notDblMtx(arg) mexErrMsgTxt("BIN_CENTER arg must be a real scalar.");
+    if (mxGetM(arg) * mxGetN(arg) != 1)
+      mexErrMsgTxt("BIN_CENTER must be a real scalar.");
+    mxMat= mxGetPr(arg);
+    origin = *mxMat;
+    }
+  else
+    origin = mean;
+
+  /* ARG 2: If positive, NBINS.  If negative, -BINSIZE. */
+  if (nrhs > 1)
+    {
+    arg = prhs[1];
+    if notDblMtx(arg) mexErrMsgTxt("NBINS_OR_BINSIZE arg must be a real scalar.");
+    if (mxGetM(arg) * mxGetN(arg) != 1)
+      mexErrMsgTxt("NBINS_OR_BINSIZE must be a real scalar.");
+    mxMat= mxGetPr(arg);
+    binsize = *mxMat;
+    }
+  else
+    {
+    binsize = 101;  /* DEFAULT: 101 bins */
+    }
+
+  /* --------------------------------------------------
+     Adjust origin, binsize, nbins such that
+        mx <= origin + (nbins-1)*binsize + PAD*binsize
+        mn >= origin - PAD*binsize
+     -------------------------------------------------- */
+  if (binsize < 0)              /* user specified BINSIZE */
+      {
+      binsize = -binsize;
+      origin -= binsize * ceil((origin-mn-PAD*binsize)/binsize);
+      nbins = (int) ceil((mx-origin-PAD*binsize)/binsize) + 1;
+      }
+  else                          /* user specified NBINS */
+      {
+      nbins = (int) (binsize + 0.5);    /* round to int */
+      if (nbins == 0)
+        mexErrMsgTxt("NBINS must be greater than zero.");
+      binsize = (mx-mn)/(nbins-1+2*PAD);   /* start with lower bound */
+      i = ceil((origin-mn-binsize/2)/binsize);
+      if ( mn < (origin-i*binsize-PAD*binsize) )
+        binsize = (origin-mn)/(i+PAD);
+      else if ( mx > (origin+(nbins-1-i)*binsize+PAD*binsize) )
+        binsize = (mx-origin)/((nbins-1-i)+PAD);
+      origin -= binsize * ceil((origin-mn-PAD*binsize)/binsize);
+      }
+
+  if (nbins > MAXBINS)
+      {
+      mexPrintf("nbins: %d,  MAXBINS: %d\n",nbins,MAXBINS);
+      mexErrMsgTxt("Number of histo bins has exceeded maximum");
+      }
+
+  /* Allocate hist  and xvals */
+  plhs[0] = (mxArray *) mxCreateDoubleMatrix(1,nbins,mxREAL);
+  if (plhs[0] == NULL) mexErrMsgTxt("Error allocating result matrix");
+  hist = mxGetPr(plhs[0]);
+
+  if (nlhs > 1)
+      {
+      plhs[1] = (mxArray *) mxCreateDoubleMatrix(1,nbins,mxREAL);
+      if (plhs[1] == NULL) mexErrMsgTxt("Error allocating result matrix");
+      bincenters = mxGetPr(plhs[1]);
+      for (i=0, temp=origin; i<nbins; i++, temp+=binsize)
+        bincenters[i] = temp;
+      }
+
+  for (i=0; i<size; i++)
+      {
+      binnum = (int) ((im[i] - origin)/binsize + 0.5);
+      if ((binnum < nbins) && (binnum >= 0))
+        (hist[binnum]) += 1.0;
+      else
+        printf("HISTO warning: value %f outside of range [%f,%f]\n",
+               im[i], origin-0.5*binsize, origin+(nbins-0.5)*binsize);
+      }
+
+  return;
+  }      
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.c b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.c
new file mode 100755
index 0000000..8fa1224
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.c
@@ -0,0 +1,52 @@
+/* 
+RES = innerProd(MAT);
+  Computes mat'*mat  
+  Odelia Schwartz, 8/97.
+*/
+
+#define V4_COMPAT
+#include <matrix.h>  
+
+#include <stdio.h>
+#include <ctype.h>
+#include <math.h>
+#include <strings.h>
+#include <stdlib.h>
+
+void mexFunction(int nlhs,           /* Num return vals on lhs */
+                 mxArray *plhs[],    /* Matrices on lhs      */
+                 int nrhs,           /* Num args on rhs    */
+                 const mxArray *prhs[]     /* Matrices on rhs */
+                 )
+{
+   register double *res, *mat, tmp;
+   register int len, wid, i, k, j, jlen, ilen, imat, jmat;
+   mxArray *arg;
+   
+   /* get matrix input argument */
+   /* should be matrix in which num rows >= num columns */
+   arg=prhs[0];                     
+   mat= mxGetPr(arg);
+   len = (int) mxGetM(arg);
+   wid = (int) mxGetN(arg);
+   if ( wid > len )
+     printf("innerProd: Warning: width %d is greater than length %d.\n",wid,len); 
+   plhs[0] = (mxArray *) mxCreateDoubleMatrix(wid,wid,mxREAL);
+   if (plhs[0] == NULL) 
+     mexErrMsgTxt(sprintf("Error allocating %dx%d result matrix",wid,wid));
+   res = mxGetPr(plhs[0]);
+
+   for(i=0, ilen=0; i<wid; i++, ilen+=len)
+     {
+      for(j=i, jlen=ilen; j<wid; j++, jlen+=len)
+         {
+            tmp = 0.0;
+            for(k=0, imat=ilen, jmat=jlen; k<len; k++, imat++, jmat++)
+              tmp += mat[imat]*mat[jmat];
+            res[i*wid+j] = tmp;
+            res[j*wid+i] = tmp;
+         }
+   }
+   return;
+
+}
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.dll b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.dll
new file mode 100755
index 0000000..40ac896
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.dll
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexa64 b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexa64
new file mode 100755
index 0000000..e31a97e
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexa64
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexglx b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexglx
new file mode 100755
index 0000000..749a5b5
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexglx
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexlx b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexlx
new file mode 100755
index 0000000..151b08f
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexlx
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexmac b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexmac
new file mode 100755
index 0000000..6e11fcd
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexmac
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexsol b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexsol
new file mode 100755
index 0000000..d761ed8
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/innerProd.mexsol
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/pointOp.c b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/pointOp.c
new file mode 100755
index 0000000..6ffcb45
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/pointOp.c
@@ -0,0 +1,126 @@
+/* 
+RES = pointOp(IM, LUT, ORIGIN, INCREMENT, WARNINGS)
+  >>> See pointOp.m for documentation <<<
+  EPS, ported from OBVIUS, 7/96.
+*/
+
+#define V4_COMPAT
+#include <matrix.h>  /* Matlab matrices */
+#include <mex.h>
+
+#include <stddef.h>  /* NULL */
+
+#define notDblMtx(it) (!mxIsNumeric(it) || !mxIsDouble(it) || mxIsSparse(it) || mxIsComplex(it))
+
+void internal_pointop();
+
+void mexFunction(int nlhs,           /* Num return vals on lhs */
+                 mxArray *plhs[],    /* Matrices on lhs      */
+                 int nrhs,           /* Num args on rhs    */
+                 const mxArray *prhs[]     /* Matrices on rhs */
+                 )
+  {
+  double *image, *lut, *res;
+  double origin, increment;
+  int x_dim, y_dim, lx_dim, ly_dim;
+  int warnings = 1;
+  mxArray *arg;
+  double *mxMat;
+
+  if (nrhs < 4 ) mexErrMsgTxt("requres  at least 4 args.");
+
+  /* ARG 1: IMAGE  */
+  arg = prhs[0];
+  if notDblMtx(arg) mexErrMsgTxt("IMAGE arg must be a real non-sparse matrix.");
+  image = mxGetPr(arg);
+  x_dim = (int) mxGetM(arg); /* X is inner index! */
+  y_dim = (int) mxGetN(arg);
+
+  /* ARG 2: Lookup table */
+  arg = prhs[1];
+  if notDblMtx(arg) mexErrMsgTxt("LUT arg must be a real non-sparse matrix.");
+  lut = mxGetPr(arg);
+  lx_dim = (int) mxGetM(arg); /* X is inner index! */
+  ly_dim = (int) mxGetN(arg);
+  if ( (lx_dim != 1) && (ly_dim != 1) )
+    mexErrMsgTxt("Lookup table must be a row or column vector.");
+
+  /* ARG 3: ORIGIN */
+  arg = prhs[2];
+  if notDblMtx(arg) mexErrMsgTxt("ORIGIN arg must be a real scalar.");
+  if (mxGetM(arg) * mxGetN(arg) != 1)
+     mexErrMsgTxt("ORIGIN arg must be a real scalar.");
+  mxMat = mxGetPr(arg);
+  origin = *mxMat;
+
+  /* ARG 4: INCREMENT */
+  arg = prhs[3];
+  if notDblMtx(arg) mexErrMsgTxt("INCREMENT arg must be a real scalar.");
+  if (mxGetM(arg) * mxGetN(arg) != 1)
+     mexErrMsgTxt("INCREMENT arg must be a real scalar.");
+  mxMat = mxGetPr(arg);
+  increment = *mxMat;
+
+  /* ARG 5: WARNINGS */
+  if (nrhs>4)
+    {
+    arg = prhs[4];
+    if notDblMtx(arg) mexErrMsgTxt("WARINGS arg must be a real scalar.");
+    if (mxGetM(arg) * mxGetN(arg) != 1)
+      mexErrMsgTxt("WARNINGS arg must be a real scalar.");
+    mxMat = mxGetPr(arg);
+    warnings = (int) *mxMat;
+    }
+
+  plhs[0] = (mxArray *)  mxCreateDoubleMatrix(x_dim,y_dim,mxREAL);
+  if (plhs[0] == NULL) mexErrMsgTxt("Cannot allocate result matrix");
+  res = mxGetPr(plhs[0]);
+      
+  internal_pointop(image, res, x_dim*y_dim, lut, lx_dim*ly_dim, 
+                   origin, increment, warnings);
+  return;
+  }      
+
+
+/* Use linear interpolation on a lookup table.
+   Taken from OBVIUS.  EPS, Spring, 1987.
+ */
+void internal_pointop (im, res, size, lut, lutsize, origin, increment, warnings)
+  register double *im, *res, *lut;
+  register double origin, increment; 
+  register int size, lutsize, warnings;
+  {
+  register int i, index;
+  register double pos;
+  register int l_unwarned = warnings;
+  register int r_unwarned = warnings;
+
+  lutsize = lutsize - 2;        /* Maximum index value */
+  if (increment > 0)
+    for (i=0; i<size; i++)
+        {
+        pos = (im[i] - origin) / increment;
+        index = (int) pos;   /* Floor */
+        if (index < 0)
+            {
+            index = 0;
+            if (l_unwarned)
+                {
+                mexPrintf("Warning: Extrapolating to left of lookup table...\n");
+                l_unwarned = 0;
+                }
+            }
+        else if (index > lutsize)
+            {
+            index = lutsize;
+            if (r_unwarned)
+                {
+                mexPrintf("Warning: Extrapolating to right of lookup table...\n");
+                r_unwarned = 0;
+                }
+            }
+        res[i] = lut[index] + (lut[index+1] - lut[index]) * (pos - index);
+        }
+  else
+    for (i=0; i<size; i++) res[i] = *lut;
+  }
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/range2.c b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/range2.c
new file mode 100755
index 0000000..b84f4e1
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/range2.c
@@ -0,0 +1,56 @@
+/* 
+[MIN, MAX] = range2(MTX)
+  >>> See range2.m for documentation <<<
+  EPS, 3/97.
+*/
+
+#define V4_COMPAT
+#include <matrix.h>  /* Matlab matrices */
+#include <mex.h>
+
+#include <stddef.h>  /* NULL */
+
+#define notDblMtx(it) (!mxIsNumeric(it) || !mxIsDouble(it) || mxIsSparse(it) || mxIsComplex(it))
+
+void mexFunction(int nlhs,           /* Num return vals on lhs */
+                 mxArray *plhs[],    /* Matrices on lhs      */
+                 int nrhs,           /* Num args on rhs    */
+                 const mxArray *prhs[]     /* Matrices on rhs */
+                 )
+  {
+  register double temp, mn, mx;
+  register double *mtx;
+  register int i, size;
+  mxArray *arg;
+
+  if (nrhs != 1) mexErrMsgTxt("requires 1 argument.");
+
+  /* ARG 1: MATRIX  */
+  arg = prhs[0];
+  if notDblMtx(arg) mexErrMsgTxt("MTX arg must be a real non-sparse matrix.");
+  mtx = mxGetPr(arg);
+  size = (int) mxGetM(arg) * mxGetN(arg);
+
+  /* FIND min, max values of MTX */
+  mn = *mtx;   mx = *mtx;  
+  for (i=1; i<size; i++)
+      {
+      temp = mtx[i];
+      if (temp < mn)
+        mn = temp;
+      else if (temp > mx)
+        mx = temp;
+      }
+
+  plhs[0] = (mxArray *) mxCreateDoubleMatrix(1,1,mxREAL);
+  if (plhs[0] == NULL) mexErrMsgTxt("Error allocating result matrix");
+  plhs[1] = (mxArray *) mxCreateDoubleMatrix(1,1,mxREAL);
+  if (plhs[1] == NULL) mexErrMsgTxt("Error allocating result matrix");
+  mtx = mxGetPr(plhs[0]);
+  mtx[0] = mn;
+  mtx = mxGetPr(plhs[1]);
+  mtx[0] = mx;
+
+  return;
+  }      
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/upConv.c b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/upConv.c
new file mode 100755
index 0000000..3708f8a
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/upConv.c
@@ -0,0 +1,195 @@
+/* 
+RES = upConv(IM, FILT, EDGES, STEP, START, STOP, RES);
+  >>> See upConv.m for documentation <<<
+  This is a matlab interface to the internal_expand function. 
+  EPS, 7/96.
+*/
+
+#define V4_COMPAT
+#include <matrix.h>  /* Matlab matrices */
+#include <mex.h>
+
+#include "convolve.h"
+
+#define notDblMtx(it) (!mxIsNumeric(it) || !mxIsDouble(it) || mxIsSparse(it) || mxIsComplex(it))
+
+void mexFunction(int nlhs,           /* Num return vals on lhs */
+                 mxArray *plhs[],    /* Matrices on lhs      */
+                 int nrhs,           /* Num args on rhs    */
+                 const mxArray *prhs[]     /* Matrices on rhs */
+                 )
+  {
+  double *image,*filt, *temp, *result, *orig_filt;
+  int x_fdim, y_fdim, x_idim, y_idim;
+  int orig_x = 0, orig_y, x, y;
+  int x_rdim, y_rdim;
+  int x_start = 1;
+  int x_step = 1;
+  int y_start = 1;
+  int y_step = 1;
+  int x_stop, y_stop;
+  mxArray *arg;
+  double *mxMat;
+  char edges[15] = "reflect1";
+
+  if (nrhs<2) mexErrMsgTxt("requres at least 2 args.");
+
+  /* ARG 1: IMAGE  */
+  arg = prhs[0];
+  if notDblMtx(arg) mexErrMsgTxt("IMAGE arg must be a non-sparse double float matrix.");
+  image = mxGetPr(arg);
+  x_idim = (int) mxGetM(arg); /* X is inner index! */
+  y_idim = (int) mxGetN(arg);
+
+  /* ARG 2: FILTER */
+  arg = prhs[1];
+  if notDblMtx(arg) mexErrMsgTxt("FILTER arg must be non-sparse double float matrix.");  filt = mxGetPr(arg);
+  x_fdim = (int) mxGetM(arg); 
+  y_fdim = (int) mxGetN(arg);
+
+  /* ARG 3 (optional): EDGES */
+  if (nrhs>2) 
+          {
+          if (!mxIsChar(prhs[2]))
+                mexErrMsgTxt("EDGES arg must be a string.");
+          mxGetString(prhs[2],edges,15);
+          }
+
+  /* ARG 4 (optional): STEP */
+  if (nrhs>3)
+      {
+      arg = prhs[3];
+      if notDblMtx(arg) mexErrMsgTxt("STEP arg must be double float matrix.");
+      if (mxGetM(arg) * mxGetN(arg) != 2)
+         mexErrMsgTxt("STEP arg must contain two elements.");
+      mxMat = mxGetPr(arg);
+      x_step = (int) mxMat[0];
+      y_step = (int) mxMat[1];
+      if ((x_step<1) || (y_step<1))
+         mexErrMsgTxt("STEP values must be greater than zero.");
+      }
+
+  /* ARG 5 (optional): START */
+  if (nrhs>4)
+      {
+      arg = prhs[4];
+      if notDblMtx(arg) mexErrMsgTxt("START arg must be double float matrix.");
+      if (mxGetM(arg) * mxGetN(arg) != 2)
+        mexErrMsgTxt("START arg must contain two elements.");
+      mxMat = mxGetPr(arg);
+      x_start = (int) mxMat[0];
+      y_start = (int) mxMat[1];
+      if ((x_start<1) || (y_start<1))
+         mexErrMsgTxt("START values must be greater than zero.");
+      }
+  x_start--;  /* convert to standard C indexes */
+  y_start--;
+
+  /* ARG 6 (optional): STOP */
+  if (nrhs>5)
+      {
+      if notDblMtx(prhs[5]) mexErrMsgTxt("STOP arg must be double float matrix.");
+      if (mxGetM(prhs[5]) * mxGetN(prhs[5]) != 2)
+         mexErrMsgTxt("STOP arg must contain two elements.");
+      mxMat = mxGetPr(prhs[5]);
+      x_stop = (int) mxMat[0];
+      y_stop = (int) mxMat[1];
+      if ((x_stop<x_start) || (y_stop<y_start))
+         mexErrMsgTxt("STOP values must be greater than START values.");
+      }
+  else
+      { /* default: make res dims a multiple of STEP size */
+      x_stop = x_step * ((x_start/x_step) + x_idim);
+      y_stop = y_step * ((y_start/y_step) + y_idim);
+      }
+
+  /* ARG 6 (optional): RESULT image */
+  if (nrhs>6)
+      {
+      arg = prhs[6];
+      if notDblMtx(arg) mexErrMsgTxt("RES arg must be double float matrix.");
+
+      /* 7/10/97: Returning one of the args causes problems with Matlab's memory 
+         manager, so we don't return anything if the result image is passed */
+      /*  plhs[0] = arg;  */
+      result = mxGetPr(arg);
+      x_rdim =  (int) mxGetM(arg); /* X is inner index! */
+      y_rdim = (int) mxGetN(arg);
+      if  ((x_stop>x_rdim) || (y_stop>y_rdim))
+        mexErrMsgTxt("STOP values must within image dimensions.");
+      }
+  else
+      {
+      x_rdim = x_stop; 
+      y_rdim = y_stop;
+      /*  x_rdim = x_step * ((x_stop+x_step-1)/x_step);
+          y_rdim = y_step * ((y_stop+y_step-1)/y_step);  */
+
+      plhs[0] = (mxArray *) mxCreateDoubleMatrix(x_rdim,y_rdim,mxREAL);
+      if (plhs[0] == NULL) mexErrMsgTxt("Cannot allocate result matrix");
+      result = mxGetPr(plhs[0]);
+      }
+          
+  if ( (((x_stop-x_start+x_step-1) / x_step) != x_idim) ||
+       (((y_stop-y_start+y_step-1) / y_step) != y_idim) )
+    {
+      mexPrintf("Im dims: [%d %d]\n",x_idim,y_idim);
+      mexPrintf("Start:   [%d %d]\n",x_start,y_start);
+      mexPrintf("Step:    [%d %d]\n",x_step,y_step);
+      mexPrintf("Stop:    [%d %d]\n",x_stop,y_stop);
+      mexPrintf("Res dims: [%d %d]\n",x_rdim,y_rdim);
+      mexErrMsgTxt("Image sizes and upsampling args are incompatible!");
+    }
+
+  /* upConv has a bug for even-length kernels when using the 
+     reflect1, extend, or repeat edge-handlers */
+  if ((!strcmp(edges,"reflect1") || !strcmp(edges,"extend") || !strcmp(edges,"repeat"))
+      &&
+      ((x_fdim%2 == 0) || (y_fdim%2 == 0)))
+      {
+      orig_filt = filt;
+      orig_x = x_fdim; 
+      orig_y = y_fdim;
+      x_fdim = 2*(orig_x/2)+1;
+      y_fdim = 2*(orig_y/2)+1;
+      filt = mxCalloc(x_fdim*y_fdim, sizeof(double));
+      if (filt == NULL)
+        mexErrMsgTxt("Cannot allocate necessary temporary space");
+      for (y=0; y<orig_y; y++)
+        for (x=0; x<orig_x; x++)
+            filt[y*x_fdim + x] = orig_filt[y*orig_x + x];
+      }
+
+  if ((x_fdim > x_rdim) || (y_fdim > y_rdim))
+    {
+    mexPrintf("Filter: [%d %d], ",x_fdim,y_fdim);
+    mexPrintf("Result: [%d %d]\n",x_rdim,y_rdim);
+    mexErrMsgTxt("FILTER dimensions larger than RESULT dimensions.");
+    }
+ 
+  temp = mxCalloc(x_fdim*y_fdim, sizeof(double));
+  if (temp == NULL)
+    mexErrMsgTxt("Cannot allocate necessary temporary space");
+
+  /*
+  printf("(%d, %d), (%d, %d), (%d, %d), (%d, %d), (%d, %d), %s\n",
+         x_idim,y_idim,x_fdim,y_fdim,x_rdim,y_rdim,
+         x_start,x_step,y_start,y_step,edges);
+         */
+
+  if (strcmp(edges,"circular") == 0)
+        internal_wrap_expand(image, filt, x_fdim, y_fdim,
+                             x_start, x_step, x_stop, y_start, y_step, y_stop,
+                             result, x_rdim, y_rdim);
+  else internal_expand(image, filt, temp, x_fdim, y_fdim,
+                       x_start, x_step, x_stop, y_start, y_step, y_stop,
+                       result, x_rdim, y_rdim, edges);
+
+  if (orig_x) mxFree((char *) filt);
+  mxFree((char *) temp);
+
+  return;
+  }      
+
+
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/wrap.c b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/wrap.c
new file mode 100755
index 0000000..a081123
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/MEX/wrap.c
@@ -0,0 +1,281 @@
+/* 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  File: wrap.c
+;;;  Author: Eero Simoncelli
+;;;  Description: Circular convolution on 2D images.
+;;;  Creation Date: Spring, 1987.
+;;;  MODIFICATIONS:
+;;;      6/96: Switched array types to double float.
+;;;      2/97: made more robust and readable.  Added STOP arguments.
+;;;  ----------------------------------------------------------------
+;;;    Object-Based Vision and Image Understanding System (OBVIUS),
+;;;      Copyright 1988, Vision Science Group,  Media Laboratory,  
+;;;              Massachusetts Institute of Technology.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+*/
+
+#include <stdlib.h>
+
+#include "convolve.h"
+
+/*
+ --------------------------------------------------------------------
+ Performs correlation (i.e., convolution with filt(-x,-y)) of FILT
+ with IMAGE followed by subsampling (a.k.a. REDUCE in Burt&Adelson81).
+ The operations are combined to avoid unnecessary computation of the
+ convolution samples that are to be discarded in the subsampling
+ operation.  The convolution is done in 9 sections so that mod
+ operations are not performed unnecessarily.  The subsampling lattice
+ is specified by the START, STEP and STOP parameters.
+ -------------------------------------------------------------------- */
+
+/* abstract out the inner product computation */
+#define INPROD(YSTART,YIND,XSTART,XIND) \
+      { \
+      sum=0.0; \
+      for (y_im=YSTART, filt_pos=0, x_filt_stop=x_fdim; \
+           x_filt_stop<=filt_size; \
+           y_im++, x_filt_stop+=x_fdim) \
+         for (x_im=XSTART ; \
+              filt_pos<x_filt_stop; \
+              filt_pos++, x_im++) \
+           sum += imval[YIND][XIND] * filt[filt_pos]; \
+      result[res_pos] = sum; \
+      }
+
+int internal_wrap_reduce(image, x_dim, y_dim, filt, x_fdim, y_fdim,
+                     x_start, x_step, x_stop, y_start, y_step, y_stop, 
+                     result)
+  register image_type *filt, *result;
+  register int x_dim, y_dim, x_fdim, y_fdim;
+  image_type *image;
+  int x_start, x_step, x_stop, y_start, y_step, y_stop;
+  {
+  register double sum;
+  register int filt_size = x_fdim*y_fdim;
+  image_type **imval;
+  register int filt_pos, x_im, y_im, x_filt_stop;
+  register int x_pos, y_pos, res_pos;
+  int x_ctr_stop = x_dim - x_fdim + 1;
+  int y_ctr_stop = y_dim - y_fdim + 1;
+  int x_ctr_start = 0;
+  int y_ctr_start = 0;
+  int x_fmid = x_fdim/2;
+  int y_fmid = y_fdim/2;
+  
+  /* shift start/stop coords to filter upper left hand corner */
+  x_start -= x_fmid;   y_start -=  y_fmid;
+  x_stop -=  x_fmid;   y_stop -=  y_fmid;
+
+  if (x_stop < x_ctr_stop) x_ctr_stop = x_stop;
+  if (y_stop < y_ctr_stop) y_ctr_stop = y_stop;
+
+  /* Set up pointer array for rows */
+  imval = (image_type **) malloc(y_dim*sizeof(image_type *));
+  if (imval IS NULL)
+      {
+      printf("INTERNAL_WRAP: Failed to allocate temp array!");
+      return(-1);
+      }
+  for (y_pos=y_im=0;y_pos<y_dim;y_pos++,y_im+=x_dim)
+    imval[y_pos] = (image+y_im);
+  
+  for (res_pos=0, y_pos=y_start;              /* TOP ROWS */
+       y_pos<y_ctr_start;
+       y_pos+=y_step)
+    {
+    for (x_pos=x_start;
+         x_pos<x_ctr_start;
+         x_pos+=x_step, res_pos++)
+      INPROD(y_pos+y_dim, y_im%y_dim, x_pos+x_dim, x_im%x_dim)
+
+    for (; 
+         x_pos<x_ctr_stop;
+         x_pos+=x_step, res_pos++) 
+      INPROD(y_pos+y_dim, y_im%y_dim, x_pos, x_im)
+
+    for (; 
+         x_pos<x_stop;
+         x_pos+=x_step, res_pos++) 
+      INPROD(y_pos+y_dim, y_im%y_dim, x_pos, x_im%x_dim)
+    } /* end TOP ROWS */
+  
+  for (;                        /* MID ROWS */
+       y_pos<y_ctr_stop;
+       y_pos+=y_step)
+    {
+    for (x_pos=x_start;
+         x_pos<x_ctr_start;
+         x_pos+=x_step, res_pos++)
+      INPROD(y_pos, y_im, x_pos+x_dim, x_im%x_dim)
+
+    for (;                      /* CENTER SECTION */
+         x_pos<x_ctr_stop;
+         x_pos+=x_step, res_pos++) 
+      INPROD(y_pos, y_im, x_pos, x_im)
+
+    for (; 
+         x_pos<x_stop;
+         x_pos+=x_step, res_pos++) 
+      INPROD(y_pos, y_im, x_pos, x_im%x_dim)
+    } /* end MID ROWS */
+  
+  for (;                        /* BOTTOM ROWS */
+       y_pos<y_stop;
+       y_pos+=y_step) 
+     {
+    for (x_pos=x_start;
+         x_pos<x_ctr_start;
+         x_pos+=x_step, res_pos++)
+      INPROD(y_pos, y_im%y_dim, x_pos+x_dim, x_im%x_dim)
+
+    for (; 
+         x_pos<x_ctr_stop; 
+         x_pos+=x_step, res_pos++) 
+      INPROD(y_pos, y_im%y_dim, x_pos, x_im)
+
+    for (;
+         x_pos<x_stop;
+         x_pos+=x_step, res_pos++) 
+      INPROD(y_pos, y_im%y_dim, x_pos, x_im%x_dim)
+    } /* end BOTTOM ROWS */
+
+  free ((image_type **) imval);
+
+  return(0);
+  }     /* end of internal_wrap_reduce */
+
+
+
+/*
+ --------------------------------------------------------------------
+ Performs upsampling (padding with zeros) followed by convolution of
+ FILT with IMAGE (a.k.a. EXPAND in Burt&Adelson81).  The operations
+ are combined to avoid unnecessary multiplication of filter samples
+ with zeros in the upsampled image.  The convolution is done in 9
+ sections so that mod operation is not performed unnecessarily.
+ Arguments are described in the comment above internal_wrap_reduce.
+
+ WARNING: this subroutine destructively modifes the RESULT image, so
+ the user must zero the result before invocation!
+ -------------------------------------------------------------------- */
+
+/* abstract out the inner product computation */
+#define INPROD2(YSTART,YIND,XSTART,XIND) \
+      { \
+      val = image[im_pos]; \
+      for (y_res=YSTART, filt_pos=0, x_filt_stop=x_fdim; \
+           x_filt_stop<=filt_size; \
+           y_res++, x_filt_stop+=x_fdim) \
+        for (x_res=XSTART; \
+             filt_pos<x_filt_stop; \
+             filt_pos++, x_res++) \
+          imval[YIND][XIND] += val * filt[filt_pos]; \
+      }
+
+int internal_wrap_expand(image, filt, x_fdim, y_fdim,
+              x_start, x_step, x_stop, y_start, y_step, y_stop,
+              result, x_dim, y_dim)
+  register image_type *filt, *result;
+  register int x_fdim, y_fdim, x_dim, y_dim;
+  image_type *image; 
+  int x_start, x_step, x_stop, y_start, y_step, y_stop;
+  {
+  register double val;
+  register int filt_size = x_fdim*y_fdim;
+  image_type **imval;
+  register int filt_pos, x_res, y_res, x_filt_stop;
+  register int x_pos, y_pos, im_pos;
+  int x_ctr_stop = x_dim - x_fdim + 1;
+  int y_ctr_stop = y_dim - y_fdim + 1;
+  int x_ctr_start = 0;
+  int y_ctr_start = 0;
+  int x_fmid = x_fdim/2;
+  int y_fmid = y_fdim/2;
+  
+  /* shift start/stop coords to filter upper left hand corner */
+  x_start -= x_fmid;   y_start -=  y_fmid;
+  x_stop -=  x_fmid;   y_stop -=  y_fmid;
+
+  if (x_stop < x_ctr_stop) x_ctr_stop = x_stop;
+  if (y_stop < y_ctr_stop) y_ctr_stop = y_stop;
+
+  /* Set up pointer array for rows */
+  imval = (image_type **) malloc(y_dim*sizeof(image_type *));
+  if (imval IS NULL)
+      {
+      printf("INTERNAL_WRAP: Failed to allocate temp array!");
+      return(-1);
+      }
+  for (y_pos=y_res=0;y_pos<y_dim;y_pos++,y_res+=x_dim)
+    imval[y_pos] = (result+y_res);
+  
+  for (im_pos=0, y_pos=y_start; /* TOP ROWS */
+       y_pos<y_ctr_start;
+       y_pos+=y_step)
+    {
+    for (x_pos=x_start; 
+         x_pos<x_ctr_start;
+         x_pos+=x_step, im_pos++)
+      INPROD2(y_pos+y_dim, y_res%y_dim, x_pos+x_dim, x_res%x_dim)
+        
+    for (; 
+         x_pos<x_ctr_stop;
+         x_pos+=x_step, im_pos++) 
+      INPROD2(y_pos+y_dim, y_res%y_dim, x_pos, x_res)
+
+    for (; 
+         x_pos<x_stop;
+         x_pos+=x_step, im_pos++) 
+      INPROD2(y_pos+y_dim, y_res%y_dim, x_pos, x_res%x_dim)
+    } /* end TOP ROWS */
+  
+  for (;                        /* MID ROWS */
+       y_pos<y_ctr_stop;
+       y_pos+=y_step)
+    {
+    for (x_pos=x_start; 
+         x_pos<x_ctr_start;
+         x_pos+=x_step, im_pos++)
+      INPROD2(y_pos, y_res, x_pos+x_dim, x_res%x_dim)
+        
+    for (;                      /* CENTER SECTION */
+         x_pos<x_ctr_stop;
+         x_pos+=x_step, im_pos++) 
+      INPROD2(y_pos, y_res, x_pos, x_res)
+
+    for (; 
+         x_pos<x_stop;
+         x_pos+=x_step, im_pos++) 
+      INPROD2(y_pos, y_res, x_pos, x_res%x_dim)
+    } /* end MID ROWS */
+  
+  for (;                        /* BOTTOM ROWS */
+       y_pos<y_stop;
+       y_pos+=y_step) 
+    {
+    for (x_pos=x_start; 
+         x_pos<x_ctr_start;
+         x_pos+=x_step, im_pos++)
+      INPROD2(y_pos, y_res%y_dim, x_pos+x_dim, x_res%x_dim)
+        
+    for (; 
+         x_pos<x_ctr_stop;
+         x_pos+=x_step, im_pos++) 
+      INPROD2(y_pos, y_res%y_dim, x_pos, x_res)
+
+    for (; 
+         x_pos<x_stop;
+         x_pos+=x_step, im_pos++) 
+      INPROD2(y_pos, y_res%y_dim, x_pos, x_res%x_dim)
+    } /* end BOTTOM ROWS */
+
+  free ((image_type **) imval);
+  return(0);
+  } /* end of internal_wrap_expand */
+
+
+
+/* Local Variables: */
+/* buffer-read-only: t */
+/* End: */
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/README b/SD-VBS/benchmarks/texture_synthesis/src/matlab/README
new file mode 100755
index 0000000..8f339f3
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/README
@@ -0,0 +1,55 @@
+This package contains some MatLab tools for multi-scale image
+processing.  Briefly, the tools include:
+  - Recursive multi-scale image decompositions (pyramids), including
+    Laplacian pyramids, QMFs, Wavelets, and steerable pyramids.  These
+    operate on 1D or 2D signals of arbitrary dimension.  Data
+    structures are compatible with the MatLab wavelet toolbox.
+  - Fast 2D convolution routines, with subsampling and boundary-handling.
+  - Fast point-operations, histograms, histogram-matching.
+  - Fast synthetic image generation: sine gratings, zone plates, fractals, etc.
+  - Display routines for images and pyramids.  These include several
+    auto-scaling options, rounding to integer zoom factors to avoid 
+    resampling artifacts, and useful labeling (dimensions and gray-range).
+
+The package is available as a gnu-zipped UNIX "tar" file, 
+accessible from the web page: 
+  http://www.cns.nyu.edu/~lcv/software.html
+
+The code works in Matlab versions 4.2 and higher, and has been fully tested
+on Linux and Macintosh OSX platforms (it should, however, port easily to
+others).  To use the code (these lines are for UNIX):
+  1) gunzip matlabPyrTools.tar.gz       # unpack g'zipped file
+  2) tar tvf matlabPyrTools.tar         # view contents
+  3) tar xvf matlabPyrTools.tar         # extract contents
+  4) rm matlabPyrTools.tar              # delete tarfile
+  5) Run matlab, and execute:
+      path(<pathname-of-matlabPyrTools>, path);
+      help matlabPyrTools
+
+A few functions are actually MEX interfaces to C code.  These are
+contained in the subdirectory called MEX.  The MEX files have been
+tested on Sun (Solaris), LinuX on a Pentium platform, and Macintosh
+OSX on a PowerPC, but should not be difficult to compile on most other
+platforms.  Source code is included in the MEX directory, as well as
+Make files.  I've included pre-compiled versions for a number of
+platforms (Solaris,Linux,Mac,Windows).  To make sure these are in your
+matlab path, you can do *one* of the following:
+  1) Create a symbolic link (or macintosh "alias") for the relavent files 
+     in the main matlabPyrTools directory,   or
+  2) Copy the relavent files into the main matlabPyrTools directory, or 
+  3) Put the MEX subdirectory in your matlab path.
+
+Some example script files showing usage of the code are in the
+directory <dir>/TUTORIALS.  There is a README file in that directory
+describing the contents.
+
+Incremental changes to the code are documented in the ChangeLog file.
+
+Comments/Suggestions/Bugs to:
+  Eero P. Simoncelli
+  Associate Professor,
+  Center for Neural Science, and
+  Courant Institute for Mathematical Sciences
+  New York University
+  eero.simoncelli@nyu.edu
+  http://www.cns.nyu.edu/~eero/
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/adjustCorr1s.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/adjustCorr1s.m
new file mode 100755
index 0000000..81f428d
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/adjustCorr1s.m
@@ -0,0 +1,63 @@
+% [newX, snr1, M] = adjustCorr1s(X, Cx, MODE, p) 
+%
+% Linearly adjust variables in X to have correlation Cx.
+% Rows of X and newX are samples of a (random) row-vector, such that:
+%    1:  newX = X * M    
+%    2:  newX' * newX = Cx 
+%
+% MODE is optional:
+%   0 => choose randomly from the space of linear solutions
+%   1 => simplest soln
+%   2 => minimize angle change (DEFAULT) 
+%   3 => SVD minimal vector change soln
+%
+% p is optional:
+%   Imposes an intermediate value of correlation between the current one
+%   C and Cx:
+%       Cx' = (1-p)*C + p*Cx;
+%   DEFAULT is p=1.
+
+%  EPS, 11/23/97.
+
+function [newX, snr1, M] = adjustCorr1s(X,Co,mode,p)
+
+if (exist('mode') ~= 1)
+  mode = 2;
+end
+
+if (exist('p') ~= 1)
+  p = 1;
+end
+
+C = innerProd(X) / size(X,1);
+[E, D] = eig(C);
+D = diag(D);
+[junk,Ind] = sort(D);
+D = diag(sqrt(D(Ind(size(Ind,1):-1:1))));
+E = E(:,Ind(size(Ind,1):-1:1));
+
+Co0 = Co;
+Co = (1-p)*C + p*Co;
+
+[Eo,Do] = eig(Co);
+Do = diag(Do);
+[junk,Ind] = sort(Do);
+Do = diag(sqrt(Do(Ind(size(Ind,1):-1:1))));
+Eo = Eo(:,Ind(size(Ind,1):-1:1));
+
+if (mode == 0)
+  Orth = orth(rand(size(C)));
+elseif (mode == 1) % eye
+  Orth = eye(size(C));
+elseif (mode == 2) % simple
+  Orth = E' * Eo;
+else     % SVD
+  [U,S,V] = svd(D * E' * Eo * inv(Do));
+  Orth = U * V';
+end
+
+M =  E * inv(D) * Orth * Do * Eo';
+
+newX = X * M;
+
+snr1=10*log10(sum(sum(Co0.^2))/sum(sum((Co0-C).^2)));
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/adjustCorr2s.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/adjustCorr2s.m
new file mode 100755
index 0000000..3bd0c2e
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/adjustCorr2s.m
@@ -0,0 +1,99 @@
+% [newX, snr1, snr2, Mx, My] = adjustCorr2s(X, Cx, Y, Cxy, MODE, p) 
+%
+% Linearly adjust variables in X to have correlation Cx, and cross-correlation Cxy.
+% Rows of X, Y, and newX are samples of (random) row-vectors, such that:
+%   1:  newX = X * Mx + Y * My
+%   2:  newX' * newX = Cx
+%   3:  newX' * Y = Cxy
+%
+% MODE is optional:
+%   0 => choose randomly from the space of linear solutions
+%   1 => simplest soln
+%   2 => minimize angle change
+%   3 => Simple rotational (DEFAULT) 
+%   4 => SVD minimal vector change soln
+%
+% p is optional:
+%   Imposes an intermediate value of correlation between the current ones
+%   Bx and Bxy and the specified Cx and Cxy:
+%       Cx' = (1-p)*Bx + p*Cx;
+%       Cxy' = (1-p)*Bxy + p*Cxy;
+%   DEFAULT is p=1.
+
+
+% EPS, 11/25/97
+
+function [newX,snr1,snr2,Mx,My] = adjustCorr2s(X, Cx, Y, Cxy, mode, p)
+
+Warn = 0; % Set to 1 if you want to display warning messages
+if (exist('mode') ~= 1)
+  mode = 3;
+end
+if (exist('p') ~= 1)
+  p = 1;
+end
+
+Bx = innerProd(X) / size(X,1);
+Bxy = (X' * Y) / size(X,1);
+By = innerProd(Y) / size(X,1);
+iBy = inv(By);
+
+Current = Bx - (Bxy * iBy * Bxy');
+Cx0 = Cx;
+Cx = (1-p)*Bx + p*Cx;
+Cxy0 = Cxy;
+Cxy = (1-p)*Bxy + p*Cxy;
+Desired = Cx - (Cxy * iBy * Cxy');
+
+[E, D] = eig(Current);
+D = diag(D);
+if any(D < 0) & Warn
+  ind = find(D<0);
+  fprintf(1,'Warning: negative current eigenvalues: %d\n',D(ind)');
+end
+[junk,Ind] = sort(D);
+D = diag(sqrt(D(Ind(size(Ind,1):-1:1))));
+E = E(:,Ind(size(Ind,1):-1:1));
+
+[Eo,Do] = eig(Desired);
+Do = diag(Do);
+if any(Do < 0) & Warn
+  ind = find(Do<0);
+  fprintf(1,'Warning: negative desired eigenvalues: %d\n',Do(ind)');
+end
+[junk,Ind] = sort(Do);
+Do = diag(sqrt(Do(Ind(size(Ind,1):-1:1))));
+Eo = Eo(:,Ind(size(Ind,1):-1:1));
+
+if (mode == 0)
+  Orth = orth(rand(size(D)));
+elseif (mode == 1) % eye
+  Orth = eye(size(D));
+elseif (mode == 2) % simple
+  A = [ eye(size(Cx)); -iBy*Bxy' ];
+  Ao =  [ eye(size(Cx)); -iBy*Cxy' ];
+  [U,S,V] = svd(E' * pinv(A) * Ao * Eo);
+  Orth = U * V';
+elseif (mode == 3)
+  Orth = E' * Eo;
+else     % SVD
+  A = [ eye(size(Cx)); -iBy*Bxy' ];
+  Ao =  [ eye(size(Cx)); -iBy*Cxy' ];
+  [U,S,V] = svd(D * E' * pinv(A) * Ao * Eo * inv(Do));
+  Orth = U * V';
+end
+
+Mx =  E * inv(D) * Orth * Do * Eo';
+My =  iBy * (Cxy' - Bxy' * Mx);
+newX = X * Mx + Y * My;
+
+if Cx0~=Bx,
+        snr1=10*log10(sum(sum(Cx0.^2))/sum(sum((Cx0-Bx).^2)));
+else
+        snr1 = Inf;
+end
+if Cxy0~=Bxy,
+        snr2=10*log10(sum(sum(Cxy0.^2))/sum(sum((Cxy0-Bxy).^2)));
+else
+        snr2 = Inf;
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/binomialFilter.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/binomialFilter.m
new file mode 100755
index 0000000..e5670c7
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/binomialFilter.m
@@ -0,0 +1,18 @@
+% KERNEL = binomialFilter(size)
+%
+% Returns a vector of binomial coefficients of order (size-1) .
+
+% Eero Simoncelli, 2/97.
+
+function [kernel] = binomialFilter(sz)
+
+if (sz < 2)
+  error('size argument must be larger than 1');
+end
+
+kernel = [0.5 0.5]';
+
+for n=1:sz-2
+  kernel = conv([0.5 0.5]', kernel);
+end
+  
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/blur.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/blur.m
new file mode 100755
index 0000000..f993d09
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/blur.m
@@ -0,0 +1,28 @@
+% RES = blur(IM, LEVELS, FILT)
+%
+% Blur an image, by filtering and downsampling LEVELS times
+% (default=1), followed by upsampling and filtering LEVELS times.  The
+% blurring is done with filter kernel specified by FILT (default =
+% 'binom5'), which can be a string (to be passed to namedFilter), a
+% vector (applied separably as a 1D convolution kernel in X and Y), or
+% a matrix (applied as a 2D convolution kernel).  The downsampling is
+% always by 2 in each direction.
+
+% Eero Simoncelli, 3/04.
+
+function res = blur(im, nlevs, filt)
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('nlevs') ~= 1) 
+  nlevs = 1;
+end
+
+if (exist('filt') ~= 1) 
+  filt = 'binom5';
+end
+
+%------------------------------------------------------------
+
+res = upBlur(blurDn(im,nlevs,filt));
\ No newline at end of file
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/blurDn.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/blurDn.m
new file mode 100755
index 0000000..8120c04
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/blurDn.m
@@ -0,0 +1,59 @@
+% RES = blurDn(IM, LEVELS, FILT)
+%
+% Blur and downsample an image.  The blurring is done with filter
+% kernel specified by FILT (default = 'binom5'), which can be a string
+% (to be passed to namedFilter), a vector (applied separably as a 1D
+% convolution kernel in X and Y), or a matrix (applied as a 2D
+% convolution kernel).  The downsampling is always by 2 in each
+% direction.
+%
+% The procedure is applied recursively LEVELS times (default=1).
+
+% Eero Simoncelli, 3/97.
+
+function res = blurDn(im, nlevs, filt)
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('nlevs') ~= 1) 
+  nlevs = 1;
+end
+
+if (exist('filt') ~= 1) 
+  filt = 'binom5';
+end
+
+%------------------------------------------------------------
+
+if isstr(filt)
+  filt = namedFilter(filt);
+end  
+
+filt = filt/sum(filt(:));
+
+if nlevs > 1
+  im = blurDn(im,nlevs-1,filt);
+end
+
+if (nlevs >= 1)
+  if (any(size(im)==1))
+    if (~any(size(filt)==1))
+      error('Cant  apply 2D filter to 1D signal');
+    end
+    if (size(im,2)==1)
+      filt = filt(:);
+    else
+      filt = filt(:)';
+    end
+    res = corrDn(im,filt,'reflect1',(size(im)~=1)+1);
+  elseif (any(size(filt)==1))
+    filt = filt(:);
+    res = corrDn(im,filt,'reflect1',[2 1]);
+    res = corrDn(res,filt','reflect1',[1 2]);
+  else
+    res = corrDn(im,filt,'reflect1',[2 2]);
+  end
+else
+  res = im;
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildGpyr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildGpyr.m
new file mode 100755
index 0000000..3f3d07b
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildGpyr.m
@@ -0,0 +1,82 @@
+% [PYR, INDICES] = buildGpyr(IM, HEIGHT, FILT, EDGES)
+%
+% Construct a Gaussian pyramid on matrix IM.
+%
+% HEIGHT (optional) specifies the number of pyramid levels to build. Default
+% is 1+maxPyrHt(size(IM),size(FILT)). 
+% You can also specify 'auto' to use this value.
+%
+% FILT (optional) can be a string naming a standard filter (see
+% namedFilter), or a vector which will be used for (separable)
+% convolution.  Default = 'binom5'.  EDGES specifies edge-handling, and
+% defaults to 'reflect1' (see corrDn).
+%
+% PYR is a vector containing the N pyramid subbands, ordered from fine
+% to coarse.  INDICES is an Nx2 matrix containing the sizes of
+% each subband.  This is compatible with the MatLab Wavelet toolbox.
+
+% Eero Simoncelli, 6/96.
+
+function [pyr,pind] = buildGpyr(im, ht, filt, edges)
+
+if (nargin < 1)
+  error('First argument (IM) is required');
+end
+
+im_sz = size(im);
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('filt') ~= 1)
+  filt = 'binom5';
+end
+
+if isstr(filt)
+  filt = namedFilter(filt);
+end
+
+if ( (size(filt,1) > 1) & (size(filt,2) > 1) )
+  error('FILT should be a 1D filter (i.e., a vector)');
+else
+  filt = filt(:);
+end
+
+max_ht = 1 + maxPyrHt(im_sz, size(filt,1));
+if ( (exist('ht') ~= 1) | (ht == 'auto') )
+  ht = max_ht;
+else
+  if (ht > max_ht)
+    error(sprintf('Cannot build pyramid higher than %d levels.',max_ht));
+  end
+end
+
+if (exist('edges') ~= 1)
+  edges= 'reflect1';
+end
+
+%------------------------------------------------------------
+
+if (ht <= 1)
+
+  pyr = im(:);
+  pind = im_sz;
+
+else
+
+  if (im_sz(2) == 1)
+    lo2 = corrDn(im, filt, edges, [2 1], [1 1]);
+  elseif (im_sz(1) == 1)
+    lo2 = corrDn(im, filt', edges, [1 2], [1 1]);
+  else
+    lo = corrDn(im, filt', edges, [1 2], [1 1]);
+    lo2 = corrDn(lo, filt, edges, [2 1], [1 1]);
+  end
+  
+  [npyr,nind] = buildGpyr(lo2, ht-1, filt, edges);
+
+  pyr = [im(:); npyr];
+  pind = [im_sz; nind];
+  
+end
+  
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildLpyr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildLpyr.m
new file mode 100755
index 0000000..facb0f3
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildLpyr.m
@@ -0,0 +1,109 @@
+% [PYR, INDICES] = buildLpyr(IM, HEIGHT, FILT1, FILT2, EDGES)
+%
+% Construct a Laplacian pyramid on matrix (or vector) IM.
+%
+% HEIGHT (optional) specifies the number of pyramid levels to build. Default
+% is 1+maxPyrHt(size(IM),size(FILT)).  You can also specify 'auto' to
+% use this value.
+%
+% FILT1 (optional) can be a string naming a standard filter (see
+% namedFilter), or a vector which will be used for (separable)
+% convolution.  Default = 'binom5'.  FILT2 specifies the "expansion"
+% filter (default = filt1).  EDGES specifies edge-handling, and
+% defaults to 'reflect1' (see corrDn).
+%
+% PYR is a vector containing the N pyramid subbands, ordered from fine
+% to coarse.  INDICES is an Nx2 matrix containing the sizes of
+% each subband.  This is compatible with the MatLab Wavelet toolbox.
+
+% Eero Simoncelli, 6/96.
+
+function [pyr,pind] = buildLpyr(im, ht, filt1, filt2, edges)
+
+if (nargin < 1)
+  error('First argument (IM) is required');
+end
+
+im_sz = size(im);
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('filt1') ~= 1)
+  filt1 = 'binom5';
+end
+ 
+if isstr(filt1)
+  filt1 = namedFilter(filt1);
+end
+
+if ( (size(filt1,1) > 1) & (size(filt1,2) > 1) )
+  error('FILT1 should be a 1D filter (i.e., a vector)');
+else
+  filt1 = filt1(:);
+end
+
+if (exist('filt2') ~= 1)
+  filt2 = filt1;
+end
+
+if isstr(filt2)
+  filt2 = namedFilter(filt2);
+end
+
+if ( (size(filt2,1) > 1) & (size(filt2,2) > 1) )
+  error('FILT2 should be a 1D filter (i.e., a vector)');
+else
+  filt2 = filt2(:);
+end
+
+max_ht = 1 + maxPyrHt(im_sz, max(size(filt1,1), size(filt2,1)));
+if ( (exist('ht') ~= 1) | (ht == 'auto') )
+  ht = max_ht;
+else
+  if (ht > max_ht)
+    error(sprintf('Cannot build pyramid higher than %d levels.',max_ht));
+  end
+end
+
+if (exist('edges') ~= 1)
+  edges= 'reflect1';
+end
+
+%------------------------------------------------------------
+
+if (ht <= 1)
+
+  pyr = im(:);
+  pind = im_sz;
+
+else
+
+  if (im_sz(2) == 1)
+    lo2 = corrDn(im, filt1, edges, [2 1], [1 1]);
+  elseif (im_sz(1) == 1)
+    lo2 = corrDn(im, filt1', edges, [1 2], [1 1]);
+  else
+    lo = corrDn(im, filt1', edges, [1 2], [1 1]);
+    int_sz = size(lo);
+    lo2 = corrDn(lo, filt1, edges, [2 1], [1 1]);
+  end
+
+  [npyr,nind] = buildLpyr(lo2, ht-1, filt1, filt2, edges);
+
+  if (im_sz(1) == 1)
+    hi2 = upConv(lo2, filt2', edges, [1 2], [1 1], im_sz);
+  elseif (im_sz(2) == 1)
+    hi2 = upConv(lo2, filt2, edges, [2 1], [1 1], im_sz);
+  else
+    hi = upConv(lo2, filt2, edges, [2 1], [1 1], int_sz);
+    hi2 = upConv(hi, filt2', edges, [1 2], [1 1], im_sz);
+  end
+
+  hi2 = im - hi2;
+
+  pyr = [hi2(:); npyr];
+  pind = [im_sz; nind];
+
+end
+  
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSCFpyr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSCFpyr.m
new file mode 100755
index 0000000..101b6d2
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSCFpyr.m
@@ -0,0 +1,90 @@
+% [PYR, INDICES, STEERMTX, HARMONICS] = buildSCFpyr(IM, HEIGHT, ORDER, TWIDTH)
+%
+% This is a modified version of buildSFpyr, that constructs a
+% complex-valued steerable pyramid  using Hilbert-transform pairs
+% of filters.  Note that the imaginary parts will *not* be steerable.
+%
+% To reconstruct from this representation, either call reconSFpyr
+% on the real part of the pyramid, *or* call reconSCFpyr which will
+% use both real and imaginary parts (forcing analyticity).
+%
+% Description of this transform appears in: Portilla & Simoncelli,
+% Int'l Journal of Computer Vision, 40(1):49-71, Oct 2000.
+% Further information: http://www.cns.nyu.edu/~eero/STEERPYR/
+
+% Original code: Eero Simoncelli, 5/97.
+% Modified by Javier Portilla to return complex (quadrature pair) channels,
+% 9/97.
+
+function [pyr,pind,steermtx,harmonics] = buildSCFpyr(im, ht, order, twidth)
+
+%-----------------------------------------------------------------
+%% DEFAULTS:
+
+max_ht = floor(log2(min(size(im)))) - 2;
+
+if (exist('ht') ~= 1)
+  ht = max_ht;
+else
+  if (ht > max_ht)
+    error(sprintf('Cannot build pyramid higher than %d levels.',max_ht));
+  end
+end
+
+if (exist('order') ~= 1)
+  order = 3;
+elseif ((order > 15)  | (order < 0))
+  fprintf(1,'Warning: ORDER must be an integer in the range [0,15]. Truncating.\n');
+  order = min(max(order,0),15);
+else
+  order = round(order);
+end
+nbands = order+1;
+
+if (exist('twidth') ~= 1)
+  twidth = 1;
+elseif (twidth <= 0)
+  fprintf(1,'Warning: TWIDTH must be positive.  Setting to 1.\n');
+  twidth = 1;
+end
+
+%-----------------------------------------------------------------
+%% Steering stuff:
+
+if (mod((nbands),2) == 0)
+  harmonics = [0:(nbands/2)-1]'*2 + 1;
+else
+  harmonics = [0:(nbands-1)/2]'*2;
+end
+
+steermtx = steer2HarmMtx(harmonics, pi*[0:nbands-1]/nbands, 'even');
+
+%-----------------------------------------------------------------
+
+dims = size(im);
+ctr = ceil((dims+0.5)/2);
+
+[xramp,yramp] = meshgrid( ([1:dims(2)]-ctr(2))./(dims(2)/2), ...
+    ([1:dims(1)]-ctr(1))./(dims(1)/2) );
+angle = atan2(yramp,xramp);
+log_rad = sqrt(xramp.^2 + yramp.^2);
+log_rad(ctr(1),ctr(2)) =  log_rad(ctr(1),ctr(2)-1);
+log_rad  = log2(log_rad);
+
+%% Radial transition function (a raised cosine in log-frequency):
+[Xrcos,Yrcos] = rcosFn(twidth,(-twidth/2),[0 1]);
+Yrcos = sqrt(Yrcos);
+
+YIrcos = sqrt(1.0 - Yrcos.^2);
+lo0mask = pointOp(log_rad, YIrcos, Xrcos(1), Xrcos(2)-Xrcos(1), 0);
+imdft = fftshift(fft2(im));
+lo0dft =  imdft .* lo0mask;
+
+[pyr,pind] = buildSCFpyrLevs(lo0dft, log_rad, Xrcos, Yrcos, angle, ht, nbands);
+
+hi0mask = pointOp(log_rad, Yrcos, Xrcos(1), Xrcos(2)-Xrcos(1), 0);
+hi0dft =  imdft .* hi0mask;
+hi0 = ifft2(ifftshift(hi0dft));
+
+pyr = [real(hi0(:)) ; pyr];
+pind = [size(hi0); pind];
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSCFpyrLevs.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSCFpyrLevs.m
new file mode 100755
index 0000000..bd75695
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSCFpyrLevs.m
@@ -0,0 +1,73 @@
+% [PYR, INDICES] = buildSCFpyrLevs(LODFT, LOGRAD, XRCOS, YRCOS, ANGLE, HEIGHT, NBANDS)
+%
+% Recursive function for constructing levels of a steerable pyramid.  This
+% is called by buildSCFpyr, and is not usually called directly.
+
+% Original code: Eero Simoncelli, 5/97.
+% Modified by Javier Portilla to generate complex bands in 9/97.
+
+function [pyr,pind] = buildSCFpyrLevs(lodft,log_rad,Xrcos,Yrcos,angle,ht,nbands);
+
+if (ht <= 0)
+
+  lo0 = ifft2(ifftshift(lodft));
+  pyr = real(lo0(:));
+  pind = size(lo0);
+
+else
+
+  bands = zeros(prod(size(lodft)), nbands);
+  bind = zeros(nbands,2);
+
+%  log_rad = log_rad + 1;
+  Xrcos = Xrcos - log2(2);  % shift origin of lut by 1 octave.
+
+  lutsize = 1024;
+  Xcosn = pi*[-(2*lutsize+1):(lutsize+1)]/lutsize;  % [-2*pi:pi]
+  order = nbands-1;
+  %% divide by sqrt(sum_(n=0)^(N-1)  cos(pi*n/N)^(2(N-1)) )
+  %% Thanks to Patrick Teo for writing this out :)
+  const = (2^(2*order))*(factorial(order)^2)/(nbands*factorial(2*order));
+
+%
+%  Ycosn = sqrt(const) * (cos(Xcosn)).^order;
+%
+  % analityc version: only take one lobe
+  alfa= mod(pi+Xcosn,2*pi)-pi;
+  Ycosn = 2*sqrt(const) * (cos(Xcosn).^order) .* (abs(alfa)<pi/2);
+
+  himask = pointOp(log_rad, Yrcos, Xrcos(1), Xrcos(2)-Xrcos(1), 0);
+
+  for b = 1:nbands
+    anglemask = pointOp(angle, Ycosn, Xcosn(1)+pi*(b-1)/nbands, Xcosn(2)-Xcosn(1));
+    banddft = ((-i)^(nbands-1)) .* lodft .* anglemask .* himask;
+    band = ifft2(ifftshift(banddft));
+
+%    bands(:,b) = real(band(:));
+    % analytic version: full complex value
+    bands(:,b)=band(:);
+    bind(b,:)  = size(band);
+  end
+
+  dims = size(lodft);
+  ctr = ceil((dims+0.5)/2);
+  lodims = ceil((dims-0.5)/2);
+  loctr = ceil((lodims+0.5)/2);
+  lostart = ctr-loctr+1;
+  loend = lostart+lodims-1;
+
+  log_rad = log_rad(lostart(1):loend(1),lostart(2):loend(2));
+  angle = angle(lostart(1):loend(1),lostart(2):loend(2));
+  lodft = lodft(lostart(1):loend(1),lostart(2):loend(2));
+  YIrcos = abs(sqrt(1.0 - Yrcos.^2));
+  lomask = pointOp(log_rad, YIrcos, Xrcos(1), Xrcos(2)-Xrcos(1), 0);
+
+  lodft = lomask .* lodft;
+
+  [npyr,nind] = buildSCFpyrLevs(lodft, log_rad, Xrcos, Yrcos, angle, ht-1, nbands);
+
+  pyr = [bands(:); npyr];
+  pind = [bind; nind];
+
+end
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSFpyr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSFpyr.m
new file mode 100755
index 0000000..ae67206
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSFpyr.m
@@ -0,0 +1,102 @@
+% [PYR, INDICES, STEERMTX, HARMONICS] = buildSFpyr(IM, HEIGHT, ORDER, TWIDTH)
+%
+% Construct a steerable pyramid on matrix IM, in the Fourier domain.
+% This is similar to buildSpyr, except that:
+%
+%    + Reconstruction is exact (within floating point errors)
+%    + It can produce any number of orientation bands.
+%    - Typically slower, especially for non-power-of-two sizes.
+%    - Boundary-handling is circular.
+%
+% HEIGHT (optional) specifies the number of pyramid levels to build. Default
+% is maxPyrHt(size(IM),size(FILT));
+%
+% The squared radial functions tile the Fourier plane, with a raised-cosine
+% falloff.  Angular functions are cos(theta-k\pi/(K+1))^K, where K is
+% the ORDER (one less than the number of orientation bands, default= 3).
+%
+% TWIDTH is the width of the transition region of the radial lowpass
+% function, in octaves (default = 1, which gives a raised cosine for
+% the bandpass filters).
+%
+% PYR is a vector containing the N pyramid subbands, ordered from fine
+% to coarse.  INDICES is an Nx2 matrix containing the sizes of
+% each subband.  This is compatible with the MatLab Wavelet toolbox.
+% See the function STEER for a description of STEERMTX and HARMONICS.
+
+% Eero Simoncelli, 5/97.
+% See http://www.cns.nyu.edu/~eero/STEERPYR/ for more
+% information about the Steerable Pyramid image decomposition.
+
+function [pyr,pind,steermtx,harmonics] = buildSFpyr(im, ht, order, twidth)
+
+%-----------------------------------------------------------------
+%% DEFAULTS:
+
+max_ht = floor(log2(min(size(im)))) - 2;
+
+if (exist('ht') ~= 1)
+  ht = max_ht;
+else
+  if (ht > max_ht)
+    error(sprintf('Cannot build pyramid higher than %d levels.',max_ht));
+  end
+end
+
+if (exist('order') ~= 1)
+  order = 3;
+elseif ((order > 15)  | (order < 0))
+  fprintf(1,'Warning: ORDER must be an integer in the range [0,15]. Truncating.\n');
+  order = min(max(order,0),15);
+else
+  order = round(order);
+end
+nbands = order+1;
+
+if (exist('twidth') ~= 1)
+  twidth = 1;
+elseif (twidth <= 0)
+  fprintf(1,'Warning: TWIDTH must be positive.  Setting to 1.\n');
+  twidth = 1;
+end
+
+%-----------------------------------------------------------------
+%% Steering stuff:
+
+if (mod((nbands),2) == 0)
+  harmonics = [0:(nbands/2)-1]'*2 + 1;
+else
+  harmonics = [0:(nbands-1)/2]'*2;
+end
+
+steermtx = steer2HarmMtx(harmonics, pi*[0:nbands-1]/nbands, 'even');
+
+%-----------------------------------------------------------------
+
+dims = size(im);
+ctr = ceil((dims+0.5)/2);
+
+[xramp,yramp] = meshgrid( ([1:dims(2)]-ctr(2))./(dims(2)/2), ...
+    ([1:dims(1)]-ctr(1))./(dims(1)/2) );
+angle = atan2(yramp,xramp);
+log_rad = sqrt(xramp.^2 + yramp.^2);
+log_rad(ctr(1),ctr(2)) =  log_rad(ctr(1),ctr(2)-1);
+log_rad  = log2(log_rad);
+
+%% Radial transition function (a raised cosine in log-frequency):
+[Xrcos,Yrcos] = rcosFn(twidth,(-twidth/2),[0 1]);
+Yrcos = sqrt(Yrcos);
+
+YIrcos = sqrt(1.0 - Yrcos.^2);
+lo0mask = pointOp(log_rad, YIrcos, Xrcos(1), Xrcos(2)-Xrcos(1), 0);
+imdft = fftshift(fft2(im));
+lo0dft =  imdft .* lo0mask;
+
+[pyr,pind] = buildSFpyrLevs(lo0dft, log_rad, Xrcos, Yrcos, angle, ht, nbands);
+
+hi0mask = pointOp(log_rad, Yrcos, Xrcos(1), Xrcos(2)-Xrcos(1), 0);
+hi0dft =  imdft .* hi0mask;
+hi0 = ifft2(ifftshift(hi0dft));
+
+pyr = [real(hi0(:)) ; pyr];
+pind = [size(hi0); pind];
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSFpyrLevs.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSFpyrLevs.m
new file mode 100755
index 0000000..472d861
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSFpyrLevs.m
@@ -0,0 +1,63 @@
+% [PYR, INDICES] = buildSFpyrLevs(LODFT, LOGRAD, XRCOS, YRCOS, ANGLE, HEIGHT, NBANDS)
+%
+% Recursive function for constructing levels of a steerable pyramid.  This
+% is called by buildSFpyr, and is not usually called directly.
+
+% Eero Simoncelli, 5/97.
+
+function [pyr,pind] = buildSFpyrLevs(lodft,log_rad,Xrcos,Yrcos,angle,ht,nbands);
+
+if (ht <= 0)
+
+  lo0 = ifft2(ifftshift(lodft));
+  pyr = real(lo0(:));
+  pind = size(lo0);
+
+else
+
+  bands = zeros(prod(size(lodft)), nbands);
+  bind = zeros(nbands,2);
+
+%  log_rad = log_rad + 1;
+  Xrcos = Xrcos - log2(2);  % shift origin of lut by 1 octave.
+
+  lutsize = 1024;
+  Xcosn = pi*[-(2*lutsize+1):(lutsize+1)]/lutsize;  % [-2*pi:pi]
+  order = nbands-1;
+  %% divide by sqrt(sum_(n=0)^(N-1)  cos(pi*n/N)^(2(N-1)) )
+  %% Thanks to Patrick Teo for writing this out :)
+  const = (2^(2*order))*(factorial(order)^2)/(nbands*factorial(2*order));
+  Ycosn = sqrt(const) * (cos(Xcosn)).^order;
+  himask = pointOp(log_rad, Yrcos, Xrcos(1), Xrcos(2)-Xrcos(1), 0);
+
+  for b = 1:nbands
+    anglemask = pointOp(angle, Ycosn, Xcosn(1)+pi*(b-1)/nbands, Xcosn(2)-Xcosn(1));
+    banddft = ((-sqrt(-1))^(nbands-1)) .* lodft .* anglemask .* himask;
+    band = ifft2(ifftshift(banddft));
+
+    bands(:,b) = real(band(:));
+    bind(b,:)  = size(band);
+  end
+
+  dims = size(lodft);
+  ctr = ceil((dims+0.5)/2);
+  lodims = ceil((dims-0.5)/2);
+  loctr = ceil((lodims+0.5)/2);
+  lostart = ctr-loctr+1;
+  loend = lostart+lodims-1;
+
+  log_rad = log_rad(lostart(1):loend(1),lostart(2):loend(2));
+  angle = angle(lostart(1):loend(1),lostart(2):loend(2));
+  lodft = lodft(lostart(1):loend(1),lostart(2):loend(2));
+  YIrcos = abs(sqrt(1.0 - Yrcos.^2));
+  lomask = pointOp(log_rad, YIrcos, Xrcos(1), Xrcos(2)-Xrcos(1), 0);
+
+  lodft = lomask .* lodft;
+
+  [npyr,nind] = buildSFpyrLevs(lodft, log_rad, Xrcos, Yrcos, angle, ht-1, nbands);
+
+  pyr = [bands(:); npyr];
+  pind = [bind; nind];
+
+end
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSpyr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSpyr.m
new file mode 100755
index 0000000..b2bead6
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSpyr.m
@@ -0,0 +1,61 @@
+% [PYR, INDICES, STEERMTX, HARMONICS] = buildSpyr(IM, HEIGHT, FILTFILE, EDGES)
+%
+% Construct a steerable pyramid on matrix IM.
+%
+% HEIGHT (optional) specifies the number of pyramid levels to build. Default
+% is maxPyrHt(size(IM),size(FILT)). 
+% You can also specify 'auto' to use this value.
+%
+% FILTFILE (optional) should be a string referring to an m-file that
+% returns the rfilters.  (examples: 'sp0Filters', 'sp1Filters',
+% 'sp3Filters','sp5Filters'.  default = 'sp1Filters'). EDGES specifies
+% edge-handling, and defaults to 'reflect1' (see corrDn).
+%
+% PYR is a vector containing the N pyramid subbands, ordered from fine
+% to coarse.  INDICES is an Nx2 matrix containing the sizes of
+% each subband.  This is compatible with the MatLab Wavelet toolbox.
+% See the function STEER for a description of STEERMTX and HARMONICS.
+
+% Eero Simoncelli, 6/96.
+% See http://www.cis.upenn.edu/~eero/steerpyr.html for more
+% information about the Steerable Pyramid image decomposition.
+
+function [pyr,pind,steermtx,harmonics] = buildSpyr(im, ht, filtfile, edges)
+
+%-----------------------------------------------------------------
+%% DEFAULTS:
+
+if (exist('filtfile') ~= 1)
+  filtfile = 'sp1Filters';
+end
+
+if (exist('edges') ~= 1)
+  edges= 'reflect1';
+end
+
+if (isstr(filtfile) & (exist(filtfile) == 2))
+   [lo0filt,hi0filt,lofilt,bfilts,steermtx,harmonics] = eval(filtfile);
+else
+  fprintf(1,'\nUse buildSFpyr for pyramids with arbitrary numbers of orientation bands.\n');
+  error('FILTFILE argument must be the name of an M-file containing SPYR filters.');
+end
+
+max_ht = maxPyrHt(size(im), size(lofilt,1));
+if ( (exist('ht') ~= 1) | (ht == 'auto') )
+  ht = max_ht;
+else
+  if (ht > max_ht)
+    error(sprintf('Cannot build pyramid higher than %d levels.',max_ht));
+  end
+end
+
+%-----------------------------------------------------------------
+
+hi0 = corrDn(im, hi0filt, edges);
+lo0 = corrDn(im, lo0filt, edges);
+
+[pyr,pind] = buildSpyrLevs(lo0, ht, lofilt, bfilts, edges);
+
+pyr = [hi0(:) ; pyr];
+pind = [size(hi0); pind];
+  
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSpyrLevs.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSpyrLevs.m
new file mode 100755
index 0000000..4c00077
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildSpyrLevs.m
@@ -0,0 +1,37 @@
+% [PYR, INDICES] = buildSpyrLevs(LOIM, HEIGHT, LOFILT, BFILTS, EDGES)
+%
+% Recursive function for constructing levels of a steerable pyramid.  This
+% is called by buildSpyr, and is not usually called directly.
+
+% Eero Simoncelli, 6/96.
+
+function [pyr,pind] = buildSpyrLevs(lo0,ht,lofilt,bfilts,edges);
+
+if (ht <= 0)
+
+  pyr = lo0(:);
+  pind = size(lo0);
+
+else
+
+  % Assume square filters:
+  bfiltsz =  round(sqrt(size(bfilts,1)));
+
+  bands = zeros(prod(size(lo0)),size(bfilts,2));
+  bind = zeros(size(bfilts,2),2);
+
+  for b = 1:size(bfilts,2)
+    filt = reshape(bfilts(:,b),bfiltsz,bfiltsz);
+    band = corrDn(lo0, filt, edges);
+    bands(:,b) = band(:);
+    bind(b,:)  = size(band);
+  end
+        
+  lo = corrDn(lo0, lofilt, edges, [2 2], [1 1]);
+  
+  [npyr,nind] = buildSpyrLevs(lo, ht-1, lofilt, bfilts, edges);
+
+  pyr = [bands(:); npyr];
+  pind = [bind; nind];
+        
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildWpyr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildWpyr.m
new file mode 100755
index 0000000..22ae32f
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/buildWpyr.m
@@ -0,0 +1,100 @@
+% [PYR, INDICES] = buildWpyr(IM, HEIGHT, FILT, EDGES)
+%
+% Construct a separable orthonormal QMF/wavelet pyramid on matrix (or vector) IM.
+%
+% HEIGHT (optional) specifies the number of pyramid levels to build. Default
+% is maxPyrHt(IM,FILT).  You can also specify 'auto' to use this value.
+%
+% FILT (optional) can be a string naming a standard filter (see
+% namedFilter), or a vector which will be used for (separable)
+% convolution.  Filter can be of even or odd length, but should be symmetric. 
+% Default = 'qmf9'.  EDGES specifies edge-handling, and
+% defaults to 'reflect1' (see corrDn).
+%
+% PYR is a vector containing the N pyramid subbands, ordered from fine
+% to coarse.  INDICES is an Nx2 matrix containing the sizes of
+% each subband.  This is compatible with the MatLab Wavelet toolbox.
+
+% Eero Simoncelli, 6/96.
+
+function [pyr,pind] = buildWpyr(im, ht, filt, edges)
+
+if (nargin < 1)
+  error('First argument (IM) is required');
+end
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('filt') ~= 1)
+  filt = 'qmf9';
+end
+
+if (exist('edges') ~= 1)
+  edges= 'reflect1';
+end
+
+if isstr(filt)
+  filt = namedFilter(filt);
+end
+
+if ( (size(filt,1) > 1) & (size(filt,2) > 1) )
+  error('FILT should be a 1D filter (i.e., a vector)');
+else
+  filt = filt(:);
+end
+
+hfilt = modulateFlip(filt);
+
+% Stagger sampling if filter is odd-length:
+if (mod(size(filt,1),2) == 0)
+  stag = 2;
+else
+  stag = 1;
+end
+
+im_sz = size(im);
+
+max_ht = maxPyrHt(im_sz, size(filt,1));
+if ( (exist('ht') ~= 1) | (ht == 'auto') )
+  ht = max_ht;
+else
+  if (ht > max_ht)
+    error(sprintf('Cannot build pyramid higher than %d levels.',max_ht));
+  end
+end
+
+if (ht <= 0)
+
+  pyr = im(:);
+  pind = im_sz;
+
+else
+
+  if (im_sz(2) == 1)
+    lolo = corrDn(im, filt, edges, [2 1], [stag 1]);
+    hihi = corrDn(im, hfilt, edges, [2 1], [2 1]);
+  elseif (im_sz(1) == 1)
+    lolo = corrDn(im, filt', edges, [1 2], [1 stag]);
+    hihi = corrDn(im, hfilt', edges, [1 2], [1 2]);
+  else
+    lo = corrDn(im, filt, edges, [2 1], [stag 1]);
+    hi = corrDn(im, hfilt, edges, [2 1], [2 1]);
+    lolo = corrDn(lo, filt', edges, [1 2], [1 stag]);
+    lohi = corrDn(hi, filt', edges, [1 2], [1 stag]); % horizontal
+    hilo = corrDn(lo, hfilt', edges, [1 2], [1 2]); % vertical
+    hihi = corrDn(hi, hfilt', edges, [1 2], [1 2]); % diagonal
+  end
+
+  [npyr,nind] = buildWpyr(lolo, ht-1, filt, edges);
+
+  if ((im_sz(1) == 1) | (im_sz(2) == 1))
+    pyr = [hihi(:); npyr];
+    pind = [size(hihi); nind];
+  else
+    pyr = [lohi(:); hilo(:); hihi(:); npyr];
+    pind = [size(lohi); size(hilo); size(hihi); nind];
+  end
+
+end
+  
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/cconv2.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/cconv2.m
new file mode 100755
index 0000000..efba438
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/cconv2.m
@@ -0,0 +1,50 @@
+% RES = CCONV2(MTX1, MTX2, CTR)
+%
+% Circular convolution of two matrices.  Result will be of size of
+% LARGER vector.
+% 
+% The origin of the smaller matrix is assumed to be its center.
+% For even dimensions, the origin is determined by the CTR (optional) 
+% argument:
+%      CTR   origin
+%       0     DIM/2      (default)
+%       1     (DIM/2)+1  
+
+% Eero Simoncelli, 6/96.  Modified 2/97.
+
+function c = cconv2(a,b,ctr)
+
+if (exist('ctr') ~= 1)
+  ctr = 0;
+end
+
+if (( size(a,1) >= size(b,1) ) & ( size(a,2) >= size(b,2) ))
+    large = a; small = b;
+elseif  (( size(a,1) <= size(b,1) ) & ( size(a,2) <= size(b,2) ))
+    large = b; small = a;
+else
+  error('one arg must be larger than the other in both dimensions!');
+end
+
+ly = size(large,1);
+lx = size(large,2);
+sy = size(small,1);
+sx = size(small,2);
+
+%% These values are the index of the small mtx that falls on the
+%% border pixel of the large matrix when computing the first
+%% convolution response sample:
+sy2 = floor((sy+ctr+1)/2);
+sx2 = floor((sx+ctr+1)/2);
+
+% pad:
+clarge = [ ...
+    large(ly-sy+sy2+1:ly,lx-sx+sx2+1:lx), large(ly-sy+sy2+1:ly,:), ...
+        large(ly-sy+sy2+1:ly,1:sx2-1); ...
+    large(:,lx-sx+sx2+1:lx), large, large(:,1:sx2-1); ...
+    large(1:sy2-1,lx-sx+sx2+1:lx), ...
+        large(1:sy2-1,:), ...
+        large(1:sy2-1,1:sx2-1) ];
+
+c = conv2(clarge,small,'valid');
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/clip.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/clip.m
new file mode 100755
index 0000000..28804f3
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/clip.m
@@ -0,0 +1,32 @@
+% [RES] = clip(IM, MINVALorRANGE, MAXVAL)
+%
+% Clip values of matrix IM to lie between minVal and maxVal:
+%      RES = max(min(IM,MAXVAL),MINVAL)
+% The first argument can also specify both min and max, as a 2-vector.
+% If only one argument is passed, the range defaults to [0,1].
+
+function res = clip(im, minValOrRange, maxVal)
+
+if (exist('minValOrRange') ~= 1) 
+  minVal = 0; 
+  maxVal = 1;
+elseif (length(minValOrRange) == 2)
+  minVal = minValOrRange(1);
+  maxVal = minValOrRange(2);
+elseif (length(minValOrRange) == 1)
+  minVal = minValOrRange;
+  if (exist('maxVal') ~= 1)
+    maxVal=minVal+1;
+  end
+else
+  error('MINVAL must be  a scalar or a 2-vector');
+end
+
+if ( maxVal < minVal )
+  error('MAXVAL should be less than MINVAL');
+end
+
+res = im;
+res(find(im < minVal)) = minVal;
+res(find(im > maxVal)) = maxVal;
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/corrDn.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/corrDn.m
new file mode 100755
index 0000000..7e07abf
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/corrDn.m
@@ -0,0 +1,63 @@
+% RES = corrDn(IM, FILT, EDGES, STEP, START, STOP)
+%
+% Compute correlation of matrices IM with FILT, followed by
+% downsampling.  These arguments should be 1D or 2D matrices, and IM
+% must be larger (in both dimensions) than FILT.  The origin of filt
+% is assumed to be floor(size(filt)/2)+1.
+% 
+% EDGES is a string determining boundary handling:
+%    'circular' - Circular convolution
+%    'reflect1' - Reflect about the edge pixels
+%    'reflect2' - Reflect, doubling the edge pixels
+%    'repeat'   - Repeat the edge pixels
+%    'zero'     - Assume values of zero outside image boundary
+%    'extend'   - Reflect and invert
+%    'dont-compute' - Zero output when filter overhangs input boundaries
+%
+% Downsampling factors are determined by STEP (optional, default=[1 1]), 
+% which should be a 2-vector [y,x].
+% 
+% The window over which the convolution occurs is specfied by START 
+% (optional, default=[1,1], and STOP (optional, default=size(IM)).
+% 
+% NOTE: this operation corresponds to multiplication of a signal
+% vector by a matrix whose rows contain copies of the FILT shifted by
+% multiples of STEP.  See upConv.m for the operation corresponding to
+% the transpose of this matrix.
+
+% Eero Simoncelli, 6/96, revised 2/97.
+
+function res = corrDn(im, filt, edges, step, start, stop)
+
+%% NOTE: THIS CODE IS NOT ACTUALLY USED! (MEX FILE IS CALLED INSTEAD)
+
+%fprintf(1,'WARNING: You should compile the MEX version of "corrDn.c",\n         found in the MEX subdirectory of matlabPyrTools, and put it in your matlab path.  It is MUCH faster, and provides more boundary-handling options.\n');
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('edges') == 1) 
+  if (strcmp(edges,'reflect1') ~= 1)
+    warning('Using REFLECT1 edge-handling (use MEX code for other options).');
+  end
+end
+
+if (exist('step') ~= 1)
+        step = [1,1];
+end     
+
+if (exist('start') ~= 1)
+        start = [1,1];
+end     
+
+if (exist('stop') ~= 1)
+        stop = size(im);
+end     
+
+%------------------------------------------------------------
+
+% Reverse order of taps in filt, to do correlation instead of convolution
+filt = filt(size(filt,1):-1:1,size(filt,2):-1:1);
+
+tmp = rconv2(im,filt);
+res = tmp(start(1):step(1):stop(1),start(2):step(2):stop(2));
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/edges-orig.c b/SD-VBS/benchmarks/texture_synthesis/src/matlab/edges-orig.c
new file mode 100755
index 0000000..1f6a98b
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/edges-orig.c
@@ -0,0 +1,494 @@
+/* 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  File: edges.c
+;;;  Author: Eero Simoncelli
+;;;  Description: Boundary handling routines for use with convolve.c
+;;;  Creation Date: Spring 1987.
+;;;  MODIFIED, 6/96, to operate on double float arrays.
+;;;  MODIFIED by dgp, 4/1/97, to support THINK C.
+;;;  ----------------------------------------------------------------
+;;;    Object-Based Vision and Image Understanding System (OBVIUS),
+;;;      Copyright 1988, Vision Science Group,  Media Laboratory,  
+;;;              Massachusetts Institute of Technology.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+*/
+
+/* 
+This file contains functions which determine how edges are to be
+handled when performing convolutions of images with linear filters.
+Any edge handling function which is local and linear may be defined,
+except (unfortunately) constants cannot be added.  So to treat the
+edges as if the image is surrounded by a gray field, you must paste it
+into a gray image, convolve, and crop it out...
+The main convolution function is called internal_filter and is defined
+in the file convolve.c.  The idea is that the convolution function
+calls the edge handling function which computes a new filter based on
+the old filter and the distance to the edge of the image.  For
+example, reflection is done by reflecting the filter through the
+appropriate axis and summing.  Currently defined functions are listed
+below.  
+*/
+
+/*
+#define DEBUG
+*/
+
+#include <stdio.h>
+#include <math.h>
+#include <string.h>
+#include "convolve.h"
+
+#define sgn(a)  ( ((a)>0)?1:(((a)<0)?-1:0) )
+#define clip(a,mn,mx)  ( ((a)<(mn))?(mn):(((a)>=(mx))?(mx-1):(a)) )
+
+int reflect1(), reflect2(), repeat(), zero(), Extend(), nocompute();
+int ereflect(), predict();
+
+/* Lookup table matching a descriptive string to the edge-handling function */
+#if !THINK_C
+        static EDGE_HANDLER edge_foos[] =
+          {
+            { "dont-compute", nocompute }, /* zero output for filter touching edge */
+            { "zero",     zero     },   /* zero outside of image */
+            { "repeat",   repeat   },   /* repeat edge pixel */
+            { "reflect1", reflect1 },   /* reflect about edge pixels  */
+            { "reflect2", reflect2 },   /* reflect image, including edge pixels  */
+            { "extend",   Extend   },   /* extend (reflect & invert) */
+            { "predict",  predict  },   /* predict based on portion covered by filt */
+            { "ereflect", ereflect },   /* orthogonal QMF reflection */
+          };
+#else
+        /*
+        This is really stupid, but THINK C won't allow initialization of static variables in
+        a code resource with string addresses. So we do it this way.
+        The 68K code for a MATLAB 4 MEX file can only be created by THINK C.
+        However, for MATLAB 5, we'll be able to use Metrowerks CodeWarrior for both 68K and PPC, so this
+        cludge can be dropped when we drop support for MATLAB 4.
+        Denis Pelli, 4/1/97. 
+        */
+        static EDGE_HANDLER edge_foos[8];
+
+        void InitializeTable(EDGE_HANDLER edge_foos[])
+        {
+                static int i=0;
+                
+                if(i>0) return;
+                edge_foos[i].name="dont-compute";
+                edge_foos[i++].func=nocompute;
+                edge_foos[i].name="zero";
+                edge_foos[i++].func=zero;
+                edge_foos[i].name="repeat";
+                edge_foos[i++].func=repeat;
+                edge_foos[i].name="reflect1";
+                edge_foos[i++].func=reflect1;
+                edge_foos[i].name="reflect2";
+                edge_foos[i++].func=reflect2;
+                edge_foos[i].name="extend";
+                edge_foos[i++].func=Extend;
+                edge_foos[i].name="predict";
+                edge_foos[i++].func=predict;
+                edge_foos[i].name="ereflect";
+                edge_foos[i++].func=ereflect;
+        }
+#endif
+
+/*
+Function looks up an edge handler id string in the structure above, and
+returns the associated function 
+*/
+fptr edge_function(char *edges)
+  {
+  int i;
+
+#if THINK_C
+  InitializeTable(edge_foos);
+#endif
+  for (i = 0; i<sizeof(edge_foos)/sizeof(EDGE_HANDLER); i++)
+    if (strcmp(edges,edge_foos[i].name) == 0)
+      return(edge_foos[i].func);
+  printf("Error: '%s' is not the name of a valid edge-handler!\n",edges);
+  for (i=0; i<sizeof(edge_foos)/sizeof(EDGE_HANDLER); i++)
+      {
+      if (i==0) printf("  Options are: ");
+      else printf(", ");
+      printf("%s",edge_foos[i].name);
+      }
+  printf("\n");
+  return(0);
+  }
+
+/* 
+---------------- EDGE HANDLER ARGUMENTS ------------------------
+filt - array of filter taps.
+x_dim, y_dim - x and y dimensions of filt.
+x_pos - position of filter relative to the horizontal image edges. Negative
+       values indicate left edge, positive indicate right edge.  Zero 
+       indicates that the filter is not touching either edge.  An absolute
+       value of 1 indicates that the edge tap of the filter is over the 
+       edge pixel of the image.
+y_pos - analogous to x_pos.
+result - array where the resulting filter will go.  The edge
+       of this filter will be aligned with the image for application...
+f_or_e - equal to one of the two constants EXPAND or FILTER.
+-------------------------------------------------------------------- 
+*/ 
+
+
+/* --------------------------------------------------------------------
+nocompute() - Return zero for values where filter hangs over the edge.
+*/
+
+int nocompute(filt,x_dim,y_dim,x_pos,y_pos,result,f_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, f_or_e;
+  {
+  register int i;
+  register int size = x_dim*y_dim;
+
+  if ( (x_pos>1) OR (x_pos<-1) OR (y_pos>1) OR (y_pos<-1) )
+    for (i=0; i<size; i++)  result[i] = 0.0;
+  else
+    for (i=0; i<size; i++)  result[i] = filt[i];
+  return(0);
+  }
+
+/* --------------------------------------------------------------------
+zero() - Zero outside of image.  Discontinuous, but adds zero energy. */
+
+int zero(filt,x_dim,y_dim,x_pos,y_pos,result,f_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, f_or_e;
+  {
+  register int y_filt,x_filt, y_res,x_res;
+  int filt_sz = x_dim*y_dim;
+  int x_start = ((x_pos>0)?(x_pos-1):((x_pos<0)?(x_pos+1):0));
+  int y_start = x_dim * ((y_pos>0)?(y_pos-1):((y_pos<0)?(y_pos+1):0));
+  int i;
+
+  for (i=0; i<filt_sz; i++) result[i] = 0.0;
+
+  for (y_filt=0, y_res=y_start;
+       y_filt<filt_sz;
+       y_filt+=x_dim, y_res+=x_dim)
+    if ((y_res >= 0) AND (y_res < filt_sz))
+      for (x_filt=y_filt, x_res=x_start;
+           x_filt<y_filt+x_dim;
+           x_filt++, x_res++)
+        if ((x_res >= 0) AND (x_res < x_dim))
+          result[y_res+x_res] = filt[x_filt];
+  return(0);
+  }
+
+/* --------------------------------------------------------------------
+repeat() - repeat edge pixel.  Continuous, but content is usually
+different from image.  
+*/
+
+int repeat(filt,x_dim,y_dim,x_pos,y_pos,result,f_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, f_or_e;
+  {
+  register int y_filt,x_filt, y_res,x_res;
+  int filt_sz = x_dim*y_dim;
+  int x_start = ((x_pos>0)?(x_pos-1):((x_pos<0)?(x_pos+1):0));
+  int y_start = x_dim * ((y_pos>0)?(y_pos-1):((y_pos<0)?(y_pos+1):0));
+  int i;
+
+  for (i=0; i<filt_sz; i++) result[i] = 0.0;
+
+  for (y_filt=0, y_res=y_start;
+       y_filt<filt_sz;
+       y_filt+=x_dim, y_res+=x_dim)
+    for (x_filt=y_filt, x_res=x_start;
+         x_filt<y_filt+x_dim;
+         x_filt++, x_res++)
+      result[((y_res>=0)?((y_res<filt_sz)?y_res:(filt_sz-x_dim)):0) 
+             + ((x_res>=0)?((x_res<x_dim)?x_res:(x_dim-1)):0)]      
+        += filt[x_filt];
+  return(0);
+  }
+
+/* --------------------------------------------------------------------
+reflect2() - "Normal" image reflection.  The edge pixel is repeated,
+then the next pixel, etc.  Continuous, attempting to maintain
+"similar" content, but discontinuous first derivative.
+*/
+
+int reflect2(filt,x_dim,y_dim,x_pos,y_pos,result,f_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, f_or_e;
+  {
+  register int y_filt,x_filt, y_edge,x_edge;
+  register int x_base = (x_pos>0)?(x_dim-1):0;
+  register int y_base = (y_pos>0)?(x_dim*(y_dim-1)):0; 
+  int filt_sz = x_dim*y_dim;
+  int x_edge_dist = (x_pos>0)?(x_pos-x_dim-1):(x_pos+1);
+  int y_edge_dist = x_dim * ((y_pos>0)?(y_pos-y_dim-1):(y_pos+1));
+  int i;
+
+  #ifdef DEBUG
+    printf("(%d,%d)  ",y_pos,x_pos);
+    if (x_pos==0) printf("\n");
+  #endif
+
+  for (i=0; i<filt_sz; i++) result[i] = 0.0;
+
+  for (y_filt=0, y_edge=y_edge_dist;
+       y_filt<filt_sz;
+       y_filt+=x_dim, y_edge+=x_dim)
+      {
+      if (y_edge IS 0) y_edge+=x_dim;
+      for (x_filt=y_filt, x_edge=x_edge_dist;
+           x_filt<y_filt+x_dim;
+           x_filt++, x_edge++)
+          {
+          if (x_edge IS 0) x_edge++;
+          result[ABS(y_base-ABS(y_edge)+x_dim) + ABS(x_base-ABS(x_edge)+1)]
+            += filt[x_filt];
+          }
+      }
+  return(0);
+  }
+
+/* --------------------------------------------------------------------
+reflect1() - Reflection through the edge pixels.  This is the right thing
+to do if you are subsampling by 2, since it maintains parity (even 
+pixels positions remain even, odd ones remain odd). (note: procedure differs 
+depending on f_or_e parameter).  */      
+
+int reflect1(filt,x_dim,y_dim,x_pos,y_pos,result,f_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, f_or_e;
+  {
+  int filt_sz = x_dim*y_dim;
+  register int x_start = 0, y_start = 0, x_stop = x_dim, y_stop = filt_sz;
+  register int y_filt,x_filt, y_edge,x_edge;
+  register int x_base = (x_pos>0)?(x_dim-1):0;
+  register int y_base = (y_pos>0)?(x_dim*(y_dim-1)):0; 
+  int x_edge_dist = (x_pos>0)?(x_pos-x_dim):((x_pos<0)?(x_pos+1):0);
+  int y_edge_dist = x_dim * ((y_pos>0)?(y_pos-y_dim):((y_pos<0)?(y_pos+1):0));
+  int i;
+  int mx_pos = (x_dim/2)+1;
+  int my_pos = (y_dim/2)+1;
+
+  #ifdef DEBUG
+    printf("(%d,%d)  ",y_pos,x_pos);
+    if (x_pos==0) printf("\n");
+  #endif
+
+  for (i=0; i<filt_sz; i++) result[i] = 0.0;
+
+  /* if EXPAND and filter is centered on image edge, do not reflect */
+  if (f_or_e IS EXPAND)
+      {
+      if (x_pos IS mx_pos) x_stop = (x_dim+1)/2;
+      else if (x_pos IS -mx_pos) { x_start = x_dim/2; x_edge_dist = 0; }
+
+      if (y_pos IS my_pos) y_stop = x_dim*((y_dim+1)/2);
+      else if (y_pos IS -my_pos) { y_start = x_dim*(y_dim/2); y_edge_dist = 0;}
+      }
+
+  /* reflect at boundary of image */
+  for (y_filt=y_start, y_edge=y_edge_dist;
+       y_filt<y_stop;
+       y_filt+=x_dim, y_edge+=x_dim)
+    for (x_filt=y_filt+x_start, x_edge=x_edge_dist;
+         x_filt<y_filt+x_stop;
+         x_filt++, x_edge++)
+        result[ABS(y_base-ABS(y_edge)) + ABS(x_base-ABS(x_edge))]
+          += filt[x_filt];
+
+  /* if EXPAND and filter is not centered on image edge, mult edge by 2 */
+    if (f_or_e IS EXPAND)
+      {
+      if ( (ABS(x_pos) ISNT mx_pos) AND (x_pos ISNT 0) )
+        for (y_filt=x_base; y_filt<filt_sz; y_filt+=x_dim)
+          result[y_filt] += result[y_filt];
+      if ( (ABS(y_pos) ISNT my_pos) AND (y_pos ISNT 0) )
+        for (x_filt=y_base; x_filt<y_base+x_dim; x_filt++)
+          result[x_filt] += result[x_filt];
+      }
+  return(0);
+  }
+
+/* --------------------------------------------------------------------
+Extend() - Extend image by reflecting and inverting about edge pixel
+value.  Maintains continuity in intensity AND first derivative (but
+not higher derivs).
+*/
+
+int Extend(filt,x_dim,y_dim,x_pos,y_pos,result,f_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, f_or_e;
+  {
+  int filt_sz = x_dim*y_dim;
+  register int x_start = 0, y_start = 0, x_stop = x_dim, y_stop = filt_sz;
+  register int y_filt,x_filt, y_edge,x_edge;
+  register int x_base = (x_pos>0)?(x_dim-1):0;
+  register int y_base = (y_pos>0)?(x_dim*(y_dim-1)):0; 
+  int x_edge_dist = (x_pos>0)?(x_pos-x_dim):((x_pos<-1)?(x_pos+1):0);
+  int y_edge_dist = x_dim * ((y_pos>0)?(y_pos-y_dim):((y_pos<-1)?(y_pos+1):0));
+  int i;
+  int mx_pos = (x_dim/2)+1;
+  int my_pos = (y_dim/2)+1;
+
+  for (i=0; i<filt_sz; i++) result[i] = 0.0;
+
+  /* if EXPAND and filter is centered on image edge, do not reflect */
+  if (f_or_e IS EXPAND)
+      {
+      if (x_pos IS mx_pos) x_stop = (x_dim+1)/2;
+      else if (x_pos IS -mx_pos) { x_start = x_dim/2; x_edge_dist = 0; }
+
+      if (y_pos IS my_pos) y_stop = x_dim*((y_dim+1)/2);
+      else if (y_pos IS -my_pos) { y_start = x_dim*(y_dim/2); y_edge_dist = 0;}
+      }
+
+  /* reflect at boundary of image */
+  for (y_filt=y_start, y_edge=y_edge_dist;
+       y_filt<y_stop;
+       y_filt+=x_dim, y_edge+=x_dim)
+    for (x_filt=y_filt+x_start, x_edge=x_edge_dist;
+         x_filt<y_filt+x_stop;
+         x_filt++, x_edge++)
+      if (((!y_base AND (sgn(y_edge) IS -1)) /* y overhanging */
+           OR
+           (y_base AND (sgn(y_edge) IS 1)))
+          ISNT                               /* XOR */
+          ((!x_base AND (sgn(x_edge) IS -1)) /* x overhanging */
+           OR
+           (x_base AND (sgn(x_edge) IS 1))))
+          {
+          result[ABS(y_base-ABS(y_edge)) + ABS(x_base-ABS(x_edge))]
+            -= filt[x_filt];
+          result[clip(y_base+y_edge,0,y_dim) + clip(x_base+x_edge,0,x_dim)]
+            += filt[x_filt] + filt[x_filt];
+          }
+      else result[ABS(y_base-ABS(y_edge)) + ABS(x_base-ABS(x_edge))]
+          += filt[x_filt];
+  return(0);
+  }
+
+/* --------------------------------------------------------------------
+predict() - Simple prediction.  Like zero, but multiplies the result
+by the reciprocal of the percentage of filter being used.  (i.e. if
+50% of the filter is hanging over the edge of the image, multiply the
+taps being used by 2).  */
+
+int predict(filt,x_dim,y_dim,x_pos,y_pos,result,f_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, f_or_e;
+  {
+  register int y_filt,x_filt, y_res,x_res;
+  register double taps_used = 0.0; /* int *** */
+  register double fraction = 0.0;
+  int filt_sz = x_dim*y_dim;
+  int x_start = ((x_pos>0)?(x_pos-1):((x_pos<0)?(x_pos+1):0));
+  int y_start = x_dim * ((y_pos>0)?(y_pos-1):((y_pos<0)?(y_pos+1):0));
+  int i;
+
+  for (i=0; i<filt_sz; i++) result[i] = 0.0;
+
+  for (y_filt=0, y_res=y_start;
+       y_filt<filt_sz;
+       y_filt+=x_dim, y_res+=x_dim)
+    if ((y_res >= 0) AND (y_res < filt_sz))
+      for (x_filt=y_filt, x_res=x_start;
+           x_filt<y_filt+x_dim;
+           x_filt++, x_res++)
+        if ((x_res >= 0) AND (x_res < x_dim))
+          {
+            result[y_res+x_res] = filt[x_filt];
+            taps_used += ABS(filt[x_filt]);
+          }
+  printf("TU: %f\n",taps_used);
+  if (f_or_e IS FILTER)
+      {
+      /* fraction = ( (double) filt_sz ) / ( (double) taps_used ); */
+      for (i=0; i<filt_sz; i++) fraction += ABS(filt[i]);
+      fraction = ( fraction / taps_used );
+      for (i=0; i<filt_sz; i++) result[i] *= fraction;
+      }
+  return(0);
+  }
+
+
+/* --------------------------------------------------------------------
+Reflect, multiplying tap of filter which is at the edge of the image
+by root 2.  This maintains orthogonality of odd-length linear-phase
+QMF filters, but it is not useful for most applications, since it
+alters the DC level.  */
+
+int ereflect(filt,x_dim,y_dim,x_pos,y_pos,result,f_or_e)
+  register double *filt, *result;
+  register int x_dim;
+  int y_dim, x_pos, y_pos, f_or_e;
+  {
+  register int y_filt,x_filt, y_edge,x_edge;
+  register int x_base = (x_pos>0)?(x_dim-1):0;
+  register int y_base = x_dim * ( (y_pos>0)?(y_dim-1):0 ); 
+  int filt_sz = x_dim*y_dim;
+  int x_edge_dist = (x_pos>1)?(x_pos-x_dim):((x_pos<-1)?(x_pos+1):0);
+  int y_edge_dist = x_dim * ( (y_pos>1)?(y_pos-y_dim):((y_pos<-1)?(y_pos+1):0) );
+  int i;
+  double norm,onorm;
+
+  for (i=0; i<filt_sz; i++) result[i] = 0.0;
+
+  /* reflect at boundary */       
+  for (y_filt=0, y_edge=y_edge_dist;
+       y_filt<filt_sz;
+       y_filt+=x_dim, y_edge+=x_dim)
+    for (x_filt=y_filt, x_edge=x_edge_dist;
+         x_filt<y_filt+x_dim;
+         x_filt++, x_edge++)
+      result[ABS(y_base-ABS(y_edge)) + ABS(x_base-ABS(x_edge))]
+        += filt[x_filt];
+
+  /* now multiply edge by root 2 */
+  if (x_pos ISNT 0) 
+    for (y_filt=x_base; y_filt<filt_sz; y_filt+=x_dim)
+      result[y_filt] *= ROOT2;
+  if (y_pos ISNT 0) 
+    for (x_filt=y_base; x_filt<y_base+x_dim; x_filt++)
+      result[x_filt] *= ROOT2;
+
+  /* now normalize to norm of original filter */
+  for (norm=0.0,i=0; i<filt_sz; i++)
+    norm += (result[i]*result[i]);
+  norm=sqrt(norm);
+
+  for (onorm=0.0,i=0; i<filt_sz; i++)
+    onorm += (filt[i]*filt[i]);
+  onorm = sqrt(onorm);
+
+  norm = norm/onorm;
+  for (i=0; i<filt_sz; i++)
+    result[i] /= norm;
+  return(0);
+  }
+
+
+/* ------- printout stuff for testing ------------------------------
+  printf("Xpos: %d, Ypos: %d", x_pos, y_pos);
+    for (y_filt=0; y_filt<y_dim; y_filt++)
+      {
+      printf("\n");
+      for (x_filt=0; x_filt<x_dim; x_filt++)
+        printf("%6.1f", result[y_filt*x_dim+x_filt]);
+      }
+  printf("\n");
+*/
+
+
+
+/* Local Variables: */
+/* buffer-read-only: t */
+/* End: */
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/einstein.pgm b/SD-VBS/benchmarks/texture_synthesis/src/matlab/einstein.pgm
new file mode 100755
index 0000000..99b974c
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/einstein.pgm
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/entropy2.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/entropy2.m
new file mode 100755
index 0000000..68a2a9f
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/entropy2.m
@@ -0,0 +1,31 @@
+% E = ENTROPY2(MTX,BINSIZE) 
+% 
+% Compute the first-order sample entropy of MTX.  Samples of VEC are
+% first discretized.  Optional argument BINSIZE controls the
+% discretization, and defaults to 256/(max(VEC)-min(VEC)).
+%
+% NOTE: This is a heavily  biased estimate of entropy when you
+% don't have much data.
+
+% Eero Simoncelli, 6/96.
+
+function res = entropy2(mtx,binsize)
+
+%% Ensure it's a vector, not a matrix.
+vec = mtx(:);
+[mn,mx] = range2(vec);
+
+if (exist('binsize') == 1)
+  nbins = max((mx-mn)/binsize, 1);
+else
+  nbins = 256;
+end
+  
+[bincount,bins] = histo(vec,nbins);
+
+%% Collect non-zero bins:
+H = bincount(find(bincount));
+H = H/sum(H);
+
+res = -sum(H .* log2(H));
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/expand.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/expand.m
new file mode 100755
index 0000000..5f6e4d9
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/expand.m
@@ -0,0 +1,34 @@
+function te = expand(t,f)
+
+% Expand spatially an image t in a factor f 
+% in X and in Y.
+% t may be complex.
+% It fills in with zeros in the Fourier domain.
+%       te = expand(t, f)
+% See also: shrink.m
+% JPM, May 95, Instituto de Optica, CSIC, Madrid.
+
+[my mx]=size(t);
+my=f*my;
+mx=f*mx;
+Te=zeros(my,mx);
+T=f^2*fftshift(fft2(t));
+y1=my/2+2-my/(2*f);
+y2=my/2+my/(2*f);
+x1=mx/2+2-mx/(2*f);
+x2=mx/2+mx/(2*f);
+Te(y1:y2,x1:x2)=T(2:my/f,2:mx/f);
+Te(y1-1,x1:x2)=T(1,2:mx/f)/2;
+Te(y2+1,x1:x2)=((T(1,mx/f:-1:2)/2)').';
+Te(y1:y2,x1-1)=T(2:my/f,1)/2;
+Te(y1:y2,x2+1)=((T(my/f:-1:2,1)/2)').';
+esq=T(1,1)/4;
+Te(y1-1,x1-1)=esq;
+Te(y1-1,x2+1)=esq;
+Te(y2+1,x1-1)=esq;
+Te(y2+1,x2+1)=esq;
+Te=fftshift(Te);
+te=ifft2(Te);
+if all(imag(t)==0),
+        te = real(te);
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/factorial.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/factorial.m
new file mode 100755
index 0000000..9255f43
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/factorial.m
@@ -0,0 +1,16 @@
+%% RES = factorial(NUM)
+%
+% Factorial function that works on matrices (matlab's does not).
+
+% EPS, 11/02
+
+function res = factorial(num)
+
+res = ones(size(num));
+
+ind = find(num > 0);
+if ( ~isempty(ind) )
+  subNum = num(ind);
+  res(ind) = subNum .* factorial(subNum-1);
+end
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/feynman.pgm b/SD-VBS/benchmarks/texture_synthesis/src/matlab/feynman.pgm
new file mode 100755
index 0000000..7d14101
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/feynman.pgm
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/histo.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/histo.m
new file mode 100755
index 0000000..8da36e5
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/histo.m
@@ -0,0 +1,58 @@
+% [N,X] = histo(MTX, nbinsOrBinsize, binCenter);
+%
+% Compute a histogram of (all) elements of MTX.  N contains the histogram
+% counts, X is a vector containg the centers of the histogram bins.
+%
+% nbinsOrBinsize (optional, default = 101) specifies either
+% the number of histogram bins, or the negative of the binsize.
+%
+% binCenter (optional, default = mean2(MTX)) specifies a center position
+% for (any one of) the histogram bins.
+%
+% How does this differ from MatLab's HIST function?  This function:
+%   - allows uniformly spaced bins only.
+%   +/- operates on all elements of MTX, instead of columnwise.
+%   + is much faster (approximately a factor of 80 on my machine).
+%   + allows specification of number of bins OR binsize.  Default=101 bins.
+%   + allows (optional) specification of binCenter.
+
+% Eero Simoncelli, 3/97.
+
+function [N, X] = histo(mtx, nbins, binCtr)
+
+%% NOTE: THIS CODE IS NOT ACTUALLY USED! (MEX FILE IS CALLED INSTEAD)
+
+%fprintf(1,'WARNING: You should compile the MEX version of "histo.c",\n         found in the MEX subdirectory of matlabPyrTools, and put it in your matlab path.  It is MUCH faster.\n');
+
+mtx = mtx(:);
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+[mn,mx] = range2(mtx);
+
+if (exist('binCtr') ~= 1) 
+  binCtr =  mean(mtx);
+end
+
+if (exist('nbins') == 1) 
+  if (nbins < 0)
+    binSize = -nbins;
+  else
+    binSize = ((mx-mn)/nbins);
+    tmpNbins = round((mx-binCtr)/binSize) - round((mn-binCtr)/binSize);
+    if (tmpNbins ~= nbins)
+      warning('Using %d bins instead of requested number (%d)',tmpNbins,nbins);
+    end
+  end
+else
+  binSize = ((mx-mn)/101);
+end
+
+firstBin = binCtr + binSize*round( (mn-binCtr)/binSize );
+
+tmpNbins = round((mx-binCtr)/binSize) - round((mn-binCtr)/binSize);
+
+bins = firstBin + binSize*[0:tmpNbins];
+
+[N, X] = hist(mtx, bins);
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/histoMatch.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/histoMatch.m
new file mode 100755
index 0000000..ab82782
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/histoMatch.m
@@ -0,0 +1,35 @@
+% RES = histoMatch(MTX, N, X)
+%
+% Modify elements of MTX so that normalized histogram matches that
+% specified by vectors X and N, where N contains the histogram counts
+% and X the histogram bin positions (see histo).
+
+% Eero Simoncelli, 7/96.
+
+function res = histoMatch(mtx, N, X)
+
+if ( exist('histo') == 3 )
+  [oN, oX] = histo(mtx(:), size(X(:),1));
+else
+  [oN, oX] = hist(mtx(:), size(X(:),1));
+end
+
+oStep = oX(2) - oX(1);
+oC = [0, cumsum(oN)]/sum(oN);
+oX = [oX(1)-oStep/2, oX+oStep/2];
+
+N = N(:)';
+X = X(:)';
+N = N + mean(N)/(1e8);   %% HACK: no empty bins ensures nC strictly monotonic
+
+nStep = X(2) - X(1);
+nC = [0, cumsum(N)]/sum(N);
+nX = [X(1)-nStep/2, X+nStep/2];
+
+nnX = interp1(nC, nX, oC, 'linear');
+
+if ( exist('pointOp') == 3 )
+  res = pointOp(mtx, nnX, oX(1), oStep);
+else
+  res = reshape(interp1(oX, nnX, mtx(:)),size(mtx,1),size(mtx,2));
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/ifftshift.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/ifftshift.m
new file mode 100755
index 0000000..2ade297
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/ifftshift.m
@@ -0,0 +1,15 @@
+% [RES] = ifftshift (MTX)
+%
+% Inverse of MatLab's FFTSHIFT.  That is,
+%     ifftshift(fftshift(MTX)) = MTX
+%   for any size MTX.
+
+% Eero Simoncelli, 2/97.
+
+function [res]  = ifftshift(mtx)
+
+sz = size(mtx);
+DC = ceil((sz+1)./2);                   % location of DC term in a matlab fft.
+
+res = [mtx(DC(1):sz(1), DC(2):sz(2)) , mtx(DC(1):sz(1), 1:DC(2)-1); ...
+       mtx(1:DC(1)-1, DC(2):sz(2)) , mtx(1:DC(1)-1, 1:DC(2)-1)];
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/imGradient.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/imGradient.m
new file mode 100755
index 0000000..23187e3
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/imGradient.m
@@ -0,0 +1,48 @@
+% [dx, dy] = imGradient(im, edges) 
+%
+% Compute the gradient of the image using smooth derivative filters
+% optimized for accurate direction estimation.  Coordinate system
+% corresponds to standard pixel indexing: X axis points rightward.  Y
+% axis points downward.  EDGES specify boundary handling (see corrDn
+% for options).
+
+% EPS, 1997.
+% original filters from Int'l Conf Image Processing, 1994.
+% updated filters 10/2003.
+% Added to matlabPyrTools 10/2004.
+
+function [dx, dy] = imGradient(im, edges) 
+
+%% 1D smoothing and differentiation kernels.
+%% See Farid & Simoncelli, IEEE Trans Image Processing, 13(4):496-508, April 2004.
+
+if (exist('edges') ~= 1)
+    edges = 'dont-compute';
+end
+
+gp = [0.037659 0.249153 0.426375 0.249153 0.037659]';
+gd = [-0.109604 -0.276691 0.000000 0.276691 0.109604]';
+
+dx = corrDn(corrDn(im, gp, edges), gd', edges);
+dy = corrDn(corrDn(im, gd, edges), gp', edges);
+
+return 
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%% TEST:
+
+%%Make a ramp with random slope and direction 
+dir = 2*pi*rand - pi;
+slope = 10*rand;
+
+sz = 32
+im = mkRamp(sz, dir, slope);
+[dx,dy] = imGradient(im);
+showIm(dx + sqrt(-1)*dy);
+
+ctr = (sz*sz/2)+sz/2;
+slopeEst = sqrt(dx(ctr).^2 + dy(ctr).^2);
+dirEst = atan2(dy(ctr), dx(ctr));
+
+[slope, slopeEst]
+[dir, dirEst]
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/imStats.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/imStats.m
new file mode 100755
index 0000000..3d79b4c
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/imStats.m
@@ -0,0 +1,41 @@
+% imStats(IM1,IM2)
+%
+% Report image (matrix) statistics.
+% When called on a single image IM1, report min, max, mean, stdev, 
+% and kurtosis.
+% When called on two images (IM1 and IM2), report min, max, mean, 
+% stdev of the difference, and also SNR (relative to IM1).
+
+% Eero Simoncelli, 6/96.
+
+function [] = imStats(im1,im2)
+
+if (~isreal(im1))
+  error('Args must be real-valued matrices');  
+end
+
+if (exist('im2') == 1)
+  difference = im1 - im2;
+  [mn,mx] = range2(difference);
+  mean = mean2(difference);
+  v = var2(difference,mean);
+  if (v < realmin) 
+    snr = Inf;
+  else
+    snr = 10 * log10(var2(im1)/v);
+  end
+  fprintf(1, 'Difference statistics:\n');
+  fprintf(1, '  Range: [%c, %c]\n',mn,mx);
+  fprintf(1, '  Mean: %f,  Stdev (rmse): %f,  SNR (dB): %f\n',...
+      mean,sqrt(v),snr);
+else
+  [mn,mx] = range2(im1);
+  mean = mean2(im1);
+  var = var2(im1);  
+  stdev = sqrt(real(var))+sqrt(imag(var));
+  kurt = kurt2(im1, mean, stdev^2);
+  fprintf(1, 'Image statistics:\n');
+  fprintf(1, '  Range: [%f, %f]\n',mn,mx);
+  fprintf(1, '  Mean: %f,  Stdev: %f,  Kurtosis: %f\n',mean,stdev,kurt);
+end
+  
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/innerProd.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/innerProd.m
new file mode 100755
index 0000000..9252c70
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/innerProd.m
@@ -0,0 +1,12 @@
+% RES = innerProd(MTX)
+%
+% Compute (MTX' * MTX) efficiently (i.e., without copying the matrix)
+
+function res = innerProd(mtx)
+
+%fprintf(1,['WARNING: You should compile the MEX version of' ...
+%          ' "innerProd.c",\n         found in the MEX subdirectory' ...
+%          ' of matlabPyrTools, and put it in your matlab path.' ...
+%          ' It is MUCH faster and requires less memory.\n']);
+
+res = mtx' * mtx;
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/kurt2.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/kurt2.m
new file mode 100755
index 0000000..8351eb4
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/kurt2.m
@@ -0,0 +1,24 @@
+% K = KURT2(MTX,MEAN,VAR)
+%
+% Sample kurtosis (fourth moment divided by squared variance) 
+% of a matrix.  Kurtosis of a Gaussian distribution is 3.
+%  MEAN (optional) and VAR (optional) make the computation faster.
+
+% Eero Simoncelli, 6/96.
+
+function res = kurt2(mtx, mn, v)
+
+if (exist('mn') ~= 1)
+        mn =  mean(mean(mtx));
+end
+
+if (exist('v') ~= 1)
+        v =  var2(mtx,mn);
+end
+
+if (isreal(mtx))
+  res = mean(mean(abs(mtx-mn).^4)) / (v^2);
+else
+  res = mean(mean(real(mtx-mn).^4)) / (real(v)^2) + ...
+      i*mean(mean(imag(mtx-mn).^4)) / (imag(v)^2);
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/lplot.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/lplot.m
new file mode 100755
index 0000000..3c67d8b
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/lplot.m
@@ -0,0 +1,43 @@
+% lplot(VEC, XRANGE)
+%
+% Plot VEC, a vector, in  "lollipop" format.  
+% XRANGE (optional, default = [1,length(VEC)]), should be a 2-vector 
+% specifying the X positions (for labeling purposes) of the first and 
+% last sample of VEC.
+
+% Mark Liberman, Linguistics Dept, UPenn, 1994.
+
+function lplot(x,xrange)
+
+if (exist('xrange') ~= 1)
+  xrange = [1,length(x)];
+end
+
+msize = size(x);
+if ( msize(2) == 1)
+  x = x';
+elseif (msize(1) ~= 1)
+  error('First arg must be a vector');
+end
+
+if (~isreal(x))
+  fprintf(1,'Warning: Imaginary part of signal ignored\n');
+  x = abs(x);
+end
+
+N = length(x);
+index = xrange(1) + (xrange(2)-xrange(1))*[0:(N-1)]/(N-1)
+xinc = index(2)-index(1);
+
+xx = [zeros(1,N);x;zeros(1,N)];
+indexis = [index;index;index];
+xdiscrete = [0 xx(:)' 0];
+idiscrete = [index(1)-xinc indexis(:)' index(N)+xinc];
+
+[mn,mx] = range2(xdiscrete);
+ypad = (mx-mn)/12;                      % MAGIC NUMBER: graph padding
+
+plot(idiscrete, xdiscrete, index, x, 'o');
+axis([index(1)-xinc, index(N)+xinc, mn-ypad, mx+ypad]);
+
+return
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/lpyrHt.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/lpyrHt.m
new file mode 100755
index 0000000..d6834d7
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/lpyrHt.m
@@ -0,0 +1,11 @@
+% [HEIGHT] = lpyrHt(INDICES)
+%
+% Compute height of Laplacian pyramid with given its INDICES matrix.
+% See buildLpyr.m
+
+% Eero Simoncelli, 6/96.
+
+function [ht] =  lpyrHt(pind)
+
+% Don't count lowpass residual band
+ht = size(pind,1)-1;
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/maxPyrHt.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/maxPyrHt.m
new file mode 100755
index 0000000..84bcf29
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/maxPyrHt.m
@@ -0,0 +1,25 @@
+% HEIGHT = maxPyrHt(IMSIZE, FILTSIZE)
+%
+% Compute maximum pyramid height for given image and filter sizes.
+% Specifically: the number of corrDn operations that can be sequentially
+% performed when subsampling by a factor of 2.
+
+% Eero Simoncelli, 6/96.
+
+function height = maxPyrHt(imsz, filtsz)
+
+imsz = imsz(:);
+filtsz = filtsz(:);
+
+if any(imsz == 1) % 1D image
+  imsz = prod(imsz);
+  filtsz = prod(filtsz);
+elseif any(filtsz == 1)              % 2D image, 1D filter
+  filtsz = [filtsz(1); filtsz(1)];
+end
+
+if any(imsz < filtsz)
+  height = 0;
+else
+  height = 1 + maxPyrHt( floor(imsz/2), filtsz ); 
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/mccExcludedFiles.log b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mccExcludedFiles.log
new file mode 100755
index 0000000..2c5359b
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mccExcludedFiles.log
@@ -0,0 +1,11 @@
+This file contains the list of various toolbox functions that are not 
+included in the CTF file. An error will be thrown if any of these functions
+ are called at run-time. Some of these functions may be from toolboxes 
+that you are not using in your application. The reason for this is that 
+these toolboxes have overloaded some methods that are called by your code. 
+If you know which toolboxes are being used by your code, you can use the -p
+ flag with the -N flag to list these toolboxes explicitly. This will 
+cause MATLAB Compiler to only look for functions in the specified toolbox 
+directories in addition to the MATLAB directories. Refer to the MCC 
+documentation for more information on this.
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/mean2.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mean2.m
new file mode 100755
index 0000000..177f7ac
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mean2.m
@@ -0,0 +1,7 @@
+% M = MEAN2(MTX)
+%
+% Sample mean of a matrix.
+
+function res = mean2(mtx)
+
+res = mean(mean(mtx));
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkAngle.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkAngle.m
new file mode 100755
index 0000000..bd54f8d
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkAngle.m
@@ -0,0 +1,32 @@
+% IM = mkAngle(SIZE, PHASE, ORIGIN)
+%
+% Compute a matrix of dimension SIZE (a [Y X] 2-vector, or a scalar)
+% containing samples of the polar angle (in radians, CW from the
+% X-axis, ranging from -pi to pi), relative to angle PHASE (default =
+% 0), about ORIGIN pixel (default = (size+1)/2).
+
+% Eero Simoncelli, 6/96.
+
+function [res] = mkAngle(sz, phase, origin)
+
+sz = sz(:);
+if (size(sz,1) == 1)
+  sz = [sz,sz];
+end
+
+% -----------------------------------------------------------------
+% OPTIONAL args:
+
+if (exist('origin') ~= 1)
+  origin = (sz+1)/2;
+end
+
+% -----------------------------------------------------------------
+
+[xramp,yramp] = meshgrid( [1:sz(2)]-origin(2), [1:sz(1)]-origin(1) );
+
+res = atan2(yramp,xramp);
+
+if (exist('phase') == 1)
+  res = mod(res+(pi-phase),2*pi)-pi;
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkAngularSine.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkAngularSine.m
new file mode 100755
index 0000000..f5238cc
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkAngularSine.m
@@ -0,0 +1,42 @@
+% IM = mkAngularSine(SIZE, HARMONIC, AMPL, PHASE, ORIGIN)
+%
+% Make an angular sinusoidal image:
+%     AMPL * sin( HARMONIC*theta + PHASE),
+% where theta is the angle about the origin.
+% SIZE specifies the matrix size, as for zeros().  
+% AMPL (default = 1) and PHASE (default = 0) are optional.
+
+% Eero Simoncelli, 2/97.
+
+function [res] = mkAngularSine(sz, harmonic, ampl, ph, origin)
+
+sz = sz(:);
+if (size(sz,1) == 1)
+  sz = [sz,sz];
+end
+
+mxsz = max(sz(1),sz(2));
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('harmonic') ~= 1)
+  harmonic = 1;
+end
+
+if (exist('ampl') ~= 1)
+  ampl = 1;
+end
+
+if (exist('ph') ~= 1)
+  ph = 0;
+end
+
+if (exist('origin') ~= 1)
+  origin = (sz+1)/2;
+end
+
+%------------------------------------------------------------
+
+res = ampl * sin(harmonic*mkAngle(sz,ph,origin) + ph);
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkDisc.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkDisc.m
new file mode 100755
index 0000000..33e7d6d
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkDisc.m
@@ -0,0 +1,61 @@
+% IM = mkDisc(SIZE, RADIUS, ORIGIN, TWIDTH, VALS)
+%
+% Make a "disk" image.  SIZE specifies the matrix size, as for
+% zeros().  RADIUS (default = min(size)/4) specifies the radius of 
+% the disk.  ORIGIN (default = (size+1)/2) specifies the 
+% location of the disk center.  TWIDTH (in pixels, default = 2) 
+% specifies the width over which a soft threshold transition is made.
+% VALS (default = [0,1]) should be a 2-vector containing the
+% intensity value inside and outside the disk.  
+
+% Eero Simoncelli, 6/96.
+
+function [res] = mkDisc(sz, rad, origin, twidth, vals)
+
+if (nargin < 1)
+  error('Must pass at least a size argument');
+end
+  
+sz = sz(:);
+if (size(sz,1) == 1)
+  sz = [sz sz];
+end
+ 
+%------------------------------------------------------------
+% OPTIONAL ARGS:
+
+if (exist('rad') ~= 1)
+  rad = min(sz(1),sz(2))/4;
+end
+
+if (exist('origin') ~= 1)
+  origin = (sz+1)./2;
+end
+
+if (exist('twidth') ~= 1)
+  twidth = 2;
+end
+
+if (exist('vals') ~= 1)
+  vals = [1,0];
+end
+
+%------------------------------------------------------------
+
+res = mkR(sz,1,origin);
+
+if (abs(twidth) < realmin)
+  res = vals(2) + (vals(1) - vals(2)) * (res <= rad);
+else
+  [Xtbl,Ytbl] = rcosFn(twidth, rad, [vals(1), vals(2)]);
+  res = pointOp(res, Ytbl, Xtbl(1), Xtbl(2)-Xtbl(1), 0);
+% 
+% OLD interp1 VERSION:
+%  res = res(:);
+%  Xtbl(1) = min(res);
+%  Xtbl(size(Xtbl,2)) = max(res);
+%  res = reshape(interp1(Xtbl,Ytbl,res), sz(1), sz(2));
+% 
+end
+  
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkFract.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkFract.m
new file mode 100755
index 0000000..af95cd5
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkFract.m
@@ -0,0 +1,36 @@
+% IM = mkFract(SIZE, FRACT_DIM)
+%
+% Make a matrix of dimensions SIZE (a [Y X] 2-vector, or a scalar)
+% containing fractal (pink) noise with power spectral density of the
+% form: 1/f^(5-2*FRACT_DIM).  Image variance is normalized to 1.0.
+% FRACT_DIM defaults to 1.0
+
+% Eero Simoncelli, 6/96.
+
+%% TODO: Verify that this  matches Mandelbrot defn of fractal dimension.
+%%       Make this more efficient!
+
+function res = mkFract(dims, fract_dim)
+
+if (exist('fract_dim') ~= 1)
+  fract_dim = 1.0;
+end
+
+res = randn(dims);
+fres = fft2(res);
+
+sz = size(res);
+ctr = ceil((sz+1)./2);
+
+shape = ifftshift(mkR(sz, -(2.5-fract_dim), ctr));
+shape(1,1) = 1;  %%DC term
+
+fres = shape .* fres;
+fres = ifft2(fres);
+
+if (max(max(abs(imag(fres)))) > 1e-10)
+  error('Symmetry error in creating fractal');
+else
+  res = real(fres);
+  res = res / sqrt(var2(res));
+end  
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkGaussian.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkGaussian.m
new file mode 100755
index 0000000..fa8a554
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkGaussian.m
@@ -0,0 +1,58 @@
+% IM = mkGaussian(SIZE, COVARIANCE, MEAN, AMPLITUDE)
+% 
+% Compute a matrix with dimensions SIZE (a [Y X] 2-vector, or a
+% scalar) containing a Gaussian function, centered at pixel position
+% specified by MEAN (default = (size+1)/2), with given COVARIANCE (can
+% be a scalar, 2-vector, or 2x2 matrix.  Default = (min(size)/6)^2),
+% and AMPLITUDE.  AMPLITUDE='norm' (default) will produce a
+% probability-normalized function.  All but the first argument are
+% optional.
+
+% Eero Simoncelli, 6/96.
+
+function [res] = mkGaussian(sz, cov, mn, ampl)
+
+sz = sz(:);
+if (size(sz,1) == 1)
+  sz = [sz,sz];
+end
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('cov') ~= 1)
+  cov = (min(sz(1),sz(2))/6)^2;
+end
+
+if (exist('mn') ~= 1)
+  mn = (sz+1)/2;
+end
+
+if (exist('ampl') ~= 1)
+  ampl = 'norm';
+end
+
+%------------------------------------------------------------
+
+[xramp,yramp] = meshgrid([1:sz(2)]-mn(2),[1:sz(1)]-mn(1));
+
+if (sum(size(cov)) == 2)  % scalar
+  if (strcmp(ampl,'norm'))  
+    ampl = 1/(2*pi*cov(1));
+  end
+  e = (xramp.^2 + yramp.^2)/(-2 * cov);
+elseif (sum(size(cov)) == 3) % a 2-vector
+  if (strcmp(ampl,'norm'))  
+    ampl = 1/(2*pi*sqrt(cov(1)*cov(2)));
+  end
+  e = xramp.^2/(-2 * cov(2)) + yramp.^2/(-2 * cov(1));
+else
+  if (strcmp(ampl,'norm'))  
+    ampl = 1/(2*pi*sqrt(det(cov)));
+  end
+  cov = -inv(cov)/2;
+  e = cov(2,2)*xramp.^2 + (cov(1,2)+cov(2,1))*(xramp.*yramp) ...
+      + cov(1,1)*yramp.^2;
+end
+  
+res = ampl .* exp(e);
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkImpulse.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkImpulse.m
new file mode 100755
index 0000000..9844ee8
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkImpulse.m
@@ -0,0 +1,25 @@
+% IM = mkImpulse(SIZE, ORIGIN, AMPLITUDE)
+%
+% Compute a matrix of dimension SIZE (a [Y X] 2-vector, or a scalar)
+% containing a single non-zero entry, at position ORIGIN (defaults to
+% ceil(size/2)), of value AMPLITUDE (defaults to 1).
+
+% Eero Simoncelli, 6/96.
+
+function [res] = mkImpulse(sz, origin, amplitude)
+
+sz = sz(:)';
+if (size(sz,2) == 1)
+  sz = [sz sz];
+end
+
+if (exist('origin') ~= 1)
+  origin = ceil(sz/2);
+end
+
+if (exist('amplitude') ~= 1)
+  amplitude = 1;
+end
+
+res = zeros(sz);
+res(origin(1),origin(2)) = amplitude;
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkR.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkR.m
new file mode 100755
index 0000000..a1e8448
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkR.m
@@ -0,0 +1,32 @@
+% IM = mkR(SIZE, EXPT, ORIGIN)
+% 
+% Compute a matrix of dimension SIZE (a [Y X] 2-vector, or a scalar)
+% containing samples of a radial ramp function, raised to power EXPT
+% (default = 1), with given ORIGIN (default = (size+1)/2, [1 1] =
+% upper left).  All but the first argument are optional.
+
+% Eero Simoncelli, 6/96.
+
+function [res] = mkR(sz, expt, origin)
+
+sz = sz(:);
+if (size(sz,1) == 1)
+  sz = [sz,sz];
+end
+ 
+% -----------------------------------------------------------------
+% OPTIONAL args:
+
+if (exist('expt') ~= 1)
+  expt = 1;
+end
+
+if (exist('origin') ~= 1)
+  origin = (sz+1)/2;
+end
+
+% -----------------------------------------------------------------
+
+[xramp,yramp] = meshgrid( [1:sz(2)]-origin(2), [1:sz(1)]-origin(1) );
+
+res = (xramp.^2 + yramp.^2).^(expt/2);
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkRamp.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkRamp.m
new file mode 100755
index 0000000..dd37164
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkRamp.m
@@ -0,0 +1,47 @@
+% IM = mkRamp(SIZE, DIRECTION, SLOPE, INTERCEPT, ORIGIN)
+%
+% Compute a matrix of dimension SIZE (a [Y X] 2-vector, or a scalar)
+% containing samples of a ramp function, with given gradient DIRECTION
+% (radians, CW from X-axis, default = 0), SLOPE (per pixel, default =
+% 1), and a value of INTERCEPT (default = 0) at the ORIGIN (default =
+% (size+1)/2, [1 1] = upper left).  All but the first argument are
+% optional.
+
+% Eero Simoncelli, 6/96. 2/97: adjusted coordinate system.
+
+function [res] = mkRamp(sz, dir, slope, intercept, origin)
+
+sz = sz(:);
+if (size(sz,1) == 1)
+  sz = [sz,sz];
+end
+
+% -----------------------------------------------------------------
+% OPTIONAL args:
+
+if (exist('dir') ~= 1)
+  dir = 0;
+end
+ 
+if (exist('slope') ~= 1)
+  slope = 1;
+end
+ 
+if (exist('intercept') ~= 1)
+  intercept = 0;
+end
+
+if (exist('origin') ~= 1)
+  origin = (sz+1)/2;
+end
+
+% -----------------------------------------------------------------
+
+xinc = slope*cos(dir);
+yinc = slope*sin(dir);
+
+[xramp,yramp] = meshgrid( xinc*([1:sz(2)]-origin(2)), ...
+    yinc*([1:sz(1)]-origin(1)) );
+ 
+res = intercept + xramp + yramp;
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkSine.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkSine.m
new file mode 100755
index 0000000..147eb01
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkSine.m
@@ -0,0 +1,67 @@
+% IM = mkSine(SIZE, PERIOD, DIRECTION, AMPLITUDE, PHASE, ORIGIN)
+%      or
+% IM = mkSine(SIZE, FREQ, AMPLITUDE, PHASE, ORIGIN)
+% 
+% Compute a matrix of dimension SIZE (a [Y X] 2-vector, or a scalar)
+% containing samples of a 2D sinusoid, with given PERIOD (in pixels),
+% DIRECTION (radians, CW from X-axis, default = 0), AMPLITUDE (default
+% = 1), and PHASE (radians, relative to ORIGIN, default = 0).  ORIGIN
+% defaults to the center of the image.
+% 
+% In the second form, FREQ is a 2-vector of frequencies (radians/pixel).
+
+% Eero Simoncelli, 6/96.
+
+function [res] = mkSine(sz, per_freq, dir_amp, amp_phase, phase_orig, orig)
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (prod(size(per_freq)) == 2)
+  frequency = norm(per_freq);
+  direction = atan2(per_freq(1),per_freq(2));
+  if (exist('dir_amp') == 1)
+    amplitude = dir_amp;
+  else
+    amplitude = 1;
+  end
+  if (exist('amp_phase') == 1)
+    phase = amp_phase;
+  else
+    phase = 0;
+  end
+  if (exist('phase_orig') == 1)
+    origin = phase_orig;
+  end
+  if (exist('orig') == 1)
+    error('Too many arguments for (second form) of mkSine');
+  end
+else
+  frequency = 2*pi/per_freq;
+  if (exist('dir_amp') == 1)
+    direction = dir_amp;
+  else
+    direction = 0;
+  end
+  if (exist('amp_phase') == 1)
+    amplitude = amp_phase;
+  else
+    amplitude = 1;
+  end
+  if (exist('phase_orig') == 1)
+    phase = phase_orig;
+  else
+    phase = 0;
+  end
+  if (exist('orig') == 1)
+    origin = orig;
+  end
+end
+
+%------------------------------------------------------------
+ 
+if (exist('origin') == 1)
+  res = amplitude*sin(mkRamp(sz, direction, frequency, phase, origin));
+else
+ res = amplitude*sin(mkRamp(sz, direction, frequency, phase));
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkSquare.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkSquare.m
new file mode 100755
index 0000000..84ef466
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkSquare.m
@@ -0,0 +1,89 @@
+% IM = mkSquare(SIZE, PERIOD, DIRECTION, AMPLITUDE, PHASE, ORIGIN, TWIDTH)
+%      or
+% IM = mkSine(SIZE, FREQ, AMPLITUDE, PHASE, ORIGIN, TWIDTH)
+% 
+% Compute a matrix of dimension SIZE (a [Y X] 2-vector, or a scalar)
+% containing samples of a 2D square wave, with given PERIOD (in
+% pixels), DIRECTION (radians, CW from X-axis, default = 0), AMPLITUDE
+% (default = 1), and PHASE (radians, relative to ORIGIN, default = 0).
+% ORIGIN defaults to the center of the image.  TWIDTH specifies width
+% of raised-cosine edges on the bars of the grating (default =
+% min(2,period/3)).
+% 
+% In the second form, FREQ is a 2-vector of frequencies (radians/pixel).
+
+% Eero Simoncelli, 6/96.
+
+% TODO: Add duty cycle.  
+
+function [res] = mkSquare(sz, per_freq, dir_amp, amp_phase, phase_orig, orig_twidth, twidth)
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (prod(size(per_freq)) == 2)
+  frequency = norm(per_freq);
+  direction = atan2(per_freq(1),per_freq(2));
+  if (exist('dir_amp') == 1)
+    amplitude = dir_amp;
+  else
+    amplitude = 1;
+  end
+  if (exist('amp_phase') == 1)
+    phase = amp_phase;
+  else
+    phase = 0;
+  end
+  if (exist('phase_orig') == 1)
+    origin = phase_orig;
+  end
+  if (exist('orig_twidth') == 1)
+    transition = orig_twidth;
+  else
+    transition = min(2,2*pi/(3*frequency));
+  end
+  if (exist('twidth') == 1)
+    error('Too many arguments for (second form) of mkSine');
+  end
+else
+  frequency = 2*pi/per_freq;
+  if (exist('dir_amp') == 1)
+    direction = dir_amp;
+  else
+    direction = 0;
+  end
+  if (exist('amp_phase') == 1)
+    amplitude = amp_phase;
+  else
+    amplitude = 1;
+  end
+  if (exist('phase_orig') == 1)
+    phase = phase_orig;
+  else
+    phase = 0;
+  end
+  if (exist('orig_twidth') == 1)
+    origin = orig_twidth;
+  end
+  if (exist('twidth') == 1)
+    transition = twidth;
+  else
+    transition = min(2,2*pi/(3*frequency));
+  end
+
+end
+
+%------------------------------------------------------------
+  
+if (exist('origin') == 1)
+  res = mkRamp(sz, direction, frequency, phase, origin) - pi/2;
+else
+  res = mkRamp(sz, direction, frequency, phase) - pi/2;
+end
+
+[Xtbl,Ytbl] = rcosFn(transition*frequency,pi/2,[-amplitude amplitude]);
+
+res = pointOp(abs(mod(res+pi, 2*pi)-pi),Ytbl,Xtbl(1),Xtbl(2)-Xtbl(1),0);
+
+% OLD threshold version: 
+%res = amplitude * (mod(res,2*pi) < pi);
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkZonePlate.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkZonePlate.m
new file mode 100755
index 0000000..2b6a4a5
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mkZonePlate.m
@@ -0,0 +1,33 @@
+% IM = mkZonePlate(SIZE, AMPL, PHASE)
+%
+% Make a "zone plate" image:
+%     AMPL * cos( r^2 + PHASE)
+% SIZE specifies the matrix size, as for zeros().  
+% AMPL (default = 1) and PHASE (default = 0) are optional.
+
+% Eero Simoncelli, 6/96.
+
+function [res] = mkZonePlate(sz, ampl, ph)
+
+sz = sz(:);
+if (size(sz,1) == 1)
+  sz = [sz,sz];
+end
+
+mxsz = max(sz(1),sz(2));
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('ampl') ~= 1)
+  ampl = 1;
+end
+
+if (exist('ph') ~= 1)
+  ph = 0;
+end
+
+%------------------------------------------------------------
+
+res = ampl * cos( (pi/mxsz) * mkR(sz,2) + ph );
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/mod.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mod.m
new file mode 100755
index 0000000..21167e5
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/mod.m
@@ -0,0 +1,14 @@
+% M = mod(A,B)
+% 
+% Modulus operator: returns A mod B.
+% Works on matrics, vectors or scalars.
+% 
+% NOTE: This function is a Matlab-5 builtin, but was missing from Matlab-4.
+
+% Eero Simoncelli, 7/96.
+
+function m = mod(a,n)
+
+m = a - n .* floor(a./n);
+return;
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/modacor22.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/modacor22.m
new file mode 100755
index 0000000..89c8d52
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/modacor22.m
@@ -0,0 +1,127 @@
+function [Y,snrV,Chf]=modacor22(X,Cy,p);
+
+% It imposes the desired autocorrelation in the given (central) samples (Cy) to
+% an image X, convolving it with an even filter of size(Cy), in such a way
+% that the image containts change as less as possible, in a LSE sense.
+%       [Y,snr,Chf]=modacor22(X,Cy,p);
+%       Chf:    Fourier transform of the filter that forces the autocorrelation
+%       p [OPTIONAL]:   mixing proportion between Cx and Cy
+%                       it imposes (1-p)*Cx + p*Cy,
+%                       being Cx the actual autocorrelation.
+%                       DEFAULT: p = 1; 
+
+% JPM, 10/97, working with EPS, NYU
+
+Warn = 0;  % Set to 1 if you want to see warning messages
+if (exist('p') ~= 1)
+  p = 1;
+end
+
+% Compute the autocorrelation function of the original image
+
+[Ny,Nx]=size(X);
+Nc=size(Cy,1);  % Normally Nc<<Nx, only the low indices of the autocorrelation  
+if (2*Nc-1 > Nx) & Warn
+  warning('Autocorrelation neighborhood too large for image: reducing');
+  Nc = 2*floor(Nx/4)-1;
+  first = (size(Cy,1)-Nc)/2;
+  Cy = Cy(first+1:first+Nc, first+1:first+Nc);
+end
+
+Xf=fft2(X);
+Xf2=abs(Xf).^2;
+Cx=fftshift(real(ifft2(Xf2)))/(2-isreal(X));
+Cy=Cy*prod(size(X));    % Unnormalize the previously normalized correlation
+
+cy=Ny/2+1;
+cx=Nx/2+1;
+Lc=(Nc-1)/2;
+Cy0 = Cy;
+Cy = p*Cy + (1-p)*Cx(cy-Lc:cy+Lc,cx-Lc:cx+Lc);
+
+% Compare the actual correlation with the desired one
+%imStats(Cx(cy-Lc:cy+Lc,cx-Lc:cx+Lc),Cy)
+snrV=10*log10(sum(sum(Cy0.^2))/sum(sum((Cy0-Cx(cy-Lc:cy+Lc,cx-Lc:cx+Lc)).^2)));
+
+% Take just the part that has influence on the samples of Cy (Cy=conv(Cx,Ch))
+Cx=Cx(cy-2*Lc:cy+2*Lc,cx-2*Lc:cx+2*Lc);
+
+% Build the matrix that performs the convolution Cy1=Tcx*Ch1
+
+Ncx=4*Lc+1;
+M=(Nc^2+1)/2;
+Tcx=zeros(M);
+
+for i=Lc+1:2*Lc,
+        for j=Lc+1:3*Lc+1,
+                nm=(i-Lc-1)*(2*Lc+1)+j-Lc;
+                ccx=Cx(i-Lc:i+Lc,j-Lc:j+Lc);
+                ccxi=ccx(2*Lc+1:-1:1,2*Lc+1:-1:1);
+                ccx=ccx+ccxi;
+                ccx(Lc+1,Lc+1)=ccx(Lc+1,Lc+1)/2;
+                ccx=vector(ccx');
+                Tcx(nm,:)=ccx(1:M)';
+        end
+end
+i=2*Lc+1;
+for j=Lc+1:2*Lc+1,
+        nm=(i-Lc-1)*(2*Lc+1)+j-Lc;
+        ccx=Cx(i-Lc:i+Lc,j-Lc:j+Lc);
+        ccxi=ccx(2*Lc+1:-1:1,2*Lc+1:-1:1);
+        ccx=ccx+ccxi;
+        ccx(Lc+1,Lc+1)=ccx(Lc+1,Lc+1)/2;
+        ccx=vector(ccx');
+        Tcx(nm,:)=ccx(1:M)';
+end
+
+% Rearrange Cy indices and solve the equation
+
+Cy1=vector(Cy');
+Cy1=Cy1(1:M);
+
+Ch1=inv(Tcx)*Cy1;
+
+% Rearrange Ch1
+
+Ch1=[Ch1;Ch1(length(Cy1)-1:-1:1)];
+Ch=reshape(Ch1,Nc,Nc)';
+
+% Compute H from Ch (H is zero-phase) through the DFT
+
+%s=2^(ceil(log(Nc)/log(2))+1);
+%H=sqrt(abs(fft2(Ch,s,s)));
+%h=fftshift(real(ifft2(H)));
+%h=h(s/2+1-Lc:s/2+1+Lc,s/2+1-Lc:s/2+1+Lc);
+%%plot(Ch);drawnow
+%h=recphase(Ch);
+
+% Compute Y as conv(X,H) in the Fourier domain
+
+%%Y=real(ifft2(Xf.*H));
+%Y=real(ifft2(Xf.*sqrt(abs(fft2(Ch,Ny,Nx)))));
+aux=zeros(Ny,Nx);
+aux(cy-Lc:cy+Lc,cx-Lc:cx+Lc)=Ch;
+Ch=fftshift(aux);
+Chf=real(fft2(Ch));
+%Chf=fft2(Ch,Ny,Nx);
+%figure(7);plot(Chf);drawnow;
+Yf=Xf.*sqrt(abs(Chf));
+Y=ifft2(Yf);
+%Y=cconv2(X,h);
+
+% Checks the fidelity of the imposition
+
+%Cy2=fftshift(real(ifft2(Xf2.*abs(Chf))))/(2-isreal(X));
+%Cy2=Cy2(cy-Lc:cy+Lc,cx-Lc:cx+Lc);
+%imStats(Cy,Cy2)
+%imStats(X,Y)
+
+%Yf2=abs(Yf).^2;
+%Cy3=fftshift(real(ifft2(Yf2)))/2;
+
+%Cy3=Cy3(cy-Lc:cy+Lc,cx-Lc:cx+Lc);
+%snr(Cy,Cy-Cy3)
+%imStats(Cy,Cy3)
+
+
+                
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/modkurt.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/modkurt.m
new file mode 100755
index 0000000..e144d32
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/modkurt.m
@@ -0,0 +1,172 @@
+function [chm, snrk] = modkurt(ch,k,p);
+
+% Modify the kurtosis in one step, by moving in gradient direction until
+% reaching the desired kurtosis value. 
+% It does not affect the mean nor the variance, but it affects the skewness.
+% This operation is not an orthogonal projection, but the projection angle is
+% near pi/2 when k is close to the original kurtosis, which is a realistic assumption
+% when doing iterative projections in a pyramid, for example (small corrections
+% to the channels' statistics). 
+%
+% [chm, snrk] = modkurt(ch,k,p);
+%       ch: channel
+%       k: desired kurtosis (k=M4/M2^2) 
+%       p [OPTIONAL]:   mixing proportion between k0 and k
+%                       it imposes (1-p)*k0 + p*k,
+%                       being k0 the current kurtosis.
+%                       DEFAULT: p = 1;
+
+
+% Javier Portilla,  Oct.12/97, NYU
+
+Warn = 0;  % Set to 1 if you want to see warning messages
+if ~exist('p'),
+  p = 1;
+end
+
+me=mean2(ch);
+ch=ch-me;
+
+% Compute the moments
+
+m=zeros(12,1);
+for n=2:12,
+        m(n)=mean2(ch.^n);
+end
+
+% The original kurtosis
+
+k0=m(4)/m(2)^2;
+snrk = snr(k, k-k0);
+if snrk > 60,
+        chm = ch+me;
+        return
+end
+k = k0*(1-p) + k*p;
+
+% Some auxiliar variables
+
+a=m(4)/m(2);
+
+% Coeficients of the numerator (A*lam^4+B*lam^3+C*lam^2+D*lam+E)
+
+A=m(12)-4*a*m(10)-4*m(3)*m(9)+6*a^2*m(8)+12*a*m(3)*m(7)+6*m(3)^2*m(6)-...
+        4*a^3*m(6)-12*a^2*m(3)*m(5)+a^4*m(4)-12*a*m(3)^2*m(4)+...
+        4*a^3*m(3)^2+6*a^2*m(3)^2*m(2)-3*m(3)^4;
+B=4*(m(10)-3*a*m(8)-3*m(3)*m(7)+3*a^2*m(6)+6*a*m(3)*m(5)+3*m(3)^2*m(4)-...
+        a^3*m(4)-3*a^2*m(3)^2-3*m(4)*m(3)^2);
+C=6*(m(8)-2*a*m(6)-2*m(3)*m(5)+a^2*m(4)+2*a*m(3)^2+m(3)^2*m(2));
+D=4*(m(6)-a^2*m(2)-m(3)^2);
+E=m(4);
+
+% Define the coefficients of the denominator (F*lam^2+G)^2
+
+F=D/4;
+G=m(2);
+
+% test
+test = 0;
+
+if test,
+
+        grd = ch.^3 - a*ch - m(3);
+        lam = -0.001:0.00001:0.001;
+        k = (A*lam.^4+B*lam.^3+C*lam.^2+D*lam+E)./...
+                (F*lam.^2 + G).^2;
+        for lam = -0.001:0.00001:0.001,
+                n = lam*100000+101;
+                chp = ch + lam*grd;
+                k2(n) = mean2(chp.^4)/mean2(chp.^2)^2;
+                %k2(n) = mean2(chp.^4);
+        end
+        lam = -0.001:0.00001:0.001;
+        snr(k2, k-k2)
+
+end % test
+
+% Now I compute its derivative with respect to lambda
+% (only the roots of derivative = 0 )
+
+d(1) = B*F;
+d(2) = 2*C*F - 4*A*G;
+d(3) = 4*F*D -3*B*G - D*F;
+d(4) = 4*F*E - 2*C*G;
+d(5) = -D*G;
+
+mMlambda = roots(d);
+
+tg = imag(mMlambda)./real(mMlambda);
+mMlambda = mMlambda(find(abs(tg)<1e-6));
+lNeg = mMlambda(find(mMlambda<0));
+if length(lNeg)==0,
+        lNeg = -1/eps;
+end
+lPos = mMlambda(find(mMlambda>=0));
+if length(lPos)==0,
+        lPos = 1/eps;
+end
+lmi = max(lNeg);
+lma = min(lPos);
+
+lam = [lmi lma];
+mMnewKt = polyval([A B C D E],lam)./(polyval([F 0 G],lam)).^2;
+kmin = min(mMnewKt);
+kmax = max(mMnewKt);
+
+% Given a desired kurtosis, solves for lambda
+
+if k<=kmin & Warn,
+        lam = lmi;
+        warning('Saturating (down) kurtosis!');
+        kmin
+elseif k>=kmax & Warn,
+        lam = lma;
+        warning('Saturating (up) kurtosis!');
+        kmax
+else
+
+% Coeficients of the algebraic equation
+
+c0 = E - k*G^2;
+c1 = D;
+c2 = C - 2*k*F*G;
+c3 = B;
+c4 = A - k*F^2;
+
+% Solves the equation
+
+r=roots([c4 c3 c2 c1 c0]);
+
+% Chose the real solution with minimum absolute value with the rigth sign
+
+tg = imag(r)./real(r);
+%lambda = real(r(find(abs(tg)<1e-6)));
+lambda = real(r(find(abs(tg)==0)));
+if length(lambda)>0,
+        lam = lambda(find(abs(lambda)==min(abs(lambda))));
+        lam = lam(1);
+else
+        lam = 0;
+end
+
+end % if ... else
+
+
+% Modify the channel
+
+chm=ch+lam*(ch.^3-a*ch-m(3));   % adjust the kurtosis
+chm=chm*sqrt(m(2)/mean2(chm.^2));       % adjust the variance
+chm=chm+me;                             % adjust the mean
+
+% Check the result
+%k2=mean2((chm-me).^4)/(mean2((chm-me).^2))^2;
+%SNR=snr(k,k-k2)
+
+
+
+
+
+
+
+
+ 
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/modskew.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/modskew.m
new file mode 100755
index 0000000..3de0e3c
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/modskew.m
@@ -0,0 +1,183 @@
+function [chm, snrk] = modskew(ch,sk,p);
+
+% Adjust the sample skewness of a vector/matrix, using gradient projection,
+% without affecting its sample mean and variance.
+%
+% This operation is not an orthogonal projection, but the projection angle is
+% near pi/2 when sk is close to the original skewness, which is a realistic
+% assumption when doing iterative projections in a pyramid, for example
+% (small corrections to the channels' statistics).
+%
+%       [xm, snrk] = modskew(x,sk,p);
+%               sk: new skweness
+%               p [OPTIONAL]:   mixing proportion between sk0 and sk 
+%                               it imposes (1-p)*sk0 + p*sk,
+%                               being sk0 the current skewness.
+%                               DEFAULT: p = 1;
+
+%
+% JPM. 2/98, IODV, CSIC
+% 4/00, CNS, NYU
+
+Warn = 0;  % Set to 1 if you want to see warning messages
+if ~exist('p'), 
+  p = 1;
+end
+
+N=prod(size(ch));       % number of samples
+me=mean2(ch);
+ch=ch-me;
+
+for n=2:6,
+        m(n)=mean2(ch.^n);
+end
+
+sd=sqrt(m(2));  % standard deviation
+s=m(3)/sd^3;    % original skewness
+snrk = snr(sk, sk-s); 
+sk = s*(1-p) + sk*p;
+
+% Define the coefficients of the numerator (A*lam^3+B*lam^2+C*lam+D)
+
+A=m(6)-3*sd*s*m(5)+3*sd^2*(s^2-1)*m(4)+sd^6*(2+3*s^2-s^4);
+B=3*(m(5)-2*sd*s*m(4)+sd^5*s^3);
+C=3*(m(4)-sd^4*(1+s^2));
+D=s*sd^3;
+
+a(7)=A^2;
+a(6)=2*A*B;
+a(5)=B^2+2*A*C;
+a(4)=2*(A*D+B*C);
+a(3)=C^2+2*B*D;
+a(2)=2*C*D;
+a(1)=D^2;
+
+% Define the coefficients of the denominator (A2+B2*lam^2)
+
+A2=sd^2;
+B2=m(4)-(1+s^2)*sd^4;
+
+b=zeros(1,7);
+b(7)=B2^3;
+b(5)=3*A2*B2^2;
+b(3)=3*A2^2*B2;
+b(1)=A2^3;
+
+
+if 0, % test
+
+        lam = -2:0.02:2;
+        S = (A*lam.^3+B*lam.^2+C*lam+D)./...
+                sqrt(b(7)*lam.^6 + b(5)*lam.^4 + b(3)*lam.^2 + b(1));
+%       grd = ch.^2 - m(2) - sd * s * ch;
+%       for lam = -1:0.01:1,
+%               n = lam*100+101;
+%               chp = ch + lam*grd;
+%               S2(n) = mean2(chp.^3)/abs(mean2(chp.^2))^(1.5);
+%       end
+        lam = -2:0.02:2;
+figure(1);plot(lam,S);grid;drawnow
+%       snr(S2, S-S2)
+
+end % test
+
+% Now I compute its derivative with respect to lambda
+
+d(8) = B*b(7);
+d(7) = 2*C*b(7) - A*b(5);
+d(6) = 3*D*b(7);
+d(5) = C*b(5) - 2*A*b(3);
+d(4) = 2*D*b(5) - B*b(3);
+d(3) = -3*A*b(1);
+d(2) = D*b(3) - 2*B*b(1);
+d(1) = -C*b(1);
+
+d = d(8:-1:1);
+mMlambda = roots(d);
+
+tg = imag(mMlambda)./real(mMlambda);
+mMlambda = real(mMlambda(find(abs(tg)<1e-6)));
+lNeg = mMlambda(find(mMlambda<0));
+if length(lNeg)==0,
+        lNeg = -1/eps;
+end
+lPos = mMlambda(find(mMlambda>=0));
+if length(lPos)==0,
+        lPos = 1/eps;
+end
+lmi = max(lNeg);
+lma = min(lPos);
+
+lam = [lmi lma];
+mMnewSt = polyval([A B C D],lam)./(polyval(b(7:-1:1),lam)).^0.5;
+skmin = min(mMnewSt);
+skmax = max(mMnewSt);
+
+
+% Given a desired skewness, solves for lambda
+
+if sk<=skmin & Warn,
+        lam = lmi;
+        warning('Saturating (down) skewness!');
+        skmin
+elseif sk>=skmax & Warn,
+        lam = lma;
+        warning('Saturating (up) skewness!');
+        skmax
+else
+
+
+% The equation is sum(c.*lam.^(0:6))=0
+
+c=a-b*sk^2;
+
+c=c(7:-1:1);
+
+r=roots(c);
+
+% Chose the real solution with minimum absolute value with the rigth sign
+lam=-Inf;
+co=0;
+for n=1:6,
+        tg = imag(r(n))/real(r(n));
+        if (abs(tg)<1e-6)&(sign(real(r(n)))==sign(sk-s)),
+                co=co+1;
+                lam(co)=real(r(n));
+        end
+end
+if min(abs(lam))==Inf & Warn,
+        display('Warning: Skew adjustment skipped!');
+        lam=0;
+end
+
+p=[A B C D];
+
+if length(lam)>1,
+        foo=sign(polyval(p,lam));
+        if any(foo==0),
+                lam = lam(find(foo==0));
+        else
+                lam = lam(find(foo==sign(sk)));         % rejects the symmetric solution
+        end
+        if length(lam)>0,
+                lam=lam(find(abs(lam)==min(abs(lam)))); % the smallest that fix the skew
+                lam=lam(1);
+        else
+                lam = 0;
+        end
+end
+end % if else
+
+% Modify the channel
+chm=ch+lam*(ch.^2-sd^2-sd*s*ch);        % adjust the skewness
+chm=chm*sqrt(m(2)/mean2(chm.^2));               % adjust the variance
+chm=chm+me;                             % adjust the mean
+                                        % (These don't affect the skewness)
+% Check the result
+%mem=mean2(chm);
+%sk2=mean2((chm-mem).^3)/mean2((chm-mem).^2).^(3/2);
+%sk - sk2
+%SNR=snr(sk,sk-sk2)
+
+
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/modulateFlip.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/modulateFlip.m
new file mode 100755
index 0000000..eb27303
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/modulateFlip.m
@@ -0,0 +1,19 @@
+% [HFILT] = modulateFlipShift(LFILT)
+%
+% QMF/Wavelet highpass filter construction: modulate by (-1)^n,
+% reverse order (and shift by one, which is handled by the convolution
+% routines).  This is an extension of the original definition of QMF's
+% (e.g., see Simoncelli90).
+
+% Eero Simoncelli, 7/96.
+
+function [hfilt] = modulateFlipShift(lfilt)
+
+lfilt = lfilt(:);
+
+sz = size(lfilt,1);
+sz2 = ceil(sz/2);
+
+ind = [sz:-1:1]';
+
+hfilt = lfilt(ind) .* (-1).^(ind-sz2);
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/namedFilter.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/namedFilter.m
new file mode 100755
index 0000000..0689dbc
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/namedFilter.m
@@ -0,0 +1,71 @@
+% KERNEL = NAMED_FILTER(NAME)
+%
+% Some standard 1D filter kernels.  These are scaled such that
+% their L2-norm is 1.0.
+%
+%  binomN             - binomial coefficient filter of order N-1
+%  haar:              - Haar wavelet.
+%  qmf8, qmf12, qmf16 - Symmetric Quadrature Mirror Filters [Johnston80]
+%  daub2,daub3,daub4  - Daubechies wavelet [Daubechies88].
+%  qmf5, qmf9, qmf13: - Symmetric Quadrature Mirror Filters [Simoncelli88,Simoncelli90]
+%
+%  See bottom of file for full citations.
+
+% Eero Simoncelli, 6/96.
+
+function [kernel] = named_filter(name)
+
+if strcmp(name(1:min(5,size(name,2))), 'binom')
+  kernel = sqrt(2) * binomialFilter(str2num(name(6:size(name,2))));
+elseif strcmp(name,'qmf5')
+  kernel = [-0.076103 0.3535534 0.8593118 0.3535534 -0.076103]';
+elseif strcmp(name,'qmf9')
+  kernel = [0.02807382 -0.060944743 -0.073386624 0.41472545 0.7973934 ...
+      0.41472545 -0.073386624 -0.060944743 0.02807382]';
+elseif strcmp(name,'qmf13')
+  kernel = [-0.014556438 0.021651438 0.039045125 -0.09800052 ...
+          -0.057827797 0.42995453 0.7737113 0.42995453 -0.057827797 ...
+          -0.09800052 0.039045125 0.021651438 -0.014556438]';
+elseif strcmp(name,'qmf8')
+  kernel = sqrt(2) * [0.00938715 -0.07065183 0.06942827 0.4899808 ...
+    0.4899808 0.06942827 -0.07065183 0.00938715 ]';
+elseif strcmp(name,'qmf12')
+  kernel = sqrt(2) * [-0.003809699 0.01885659 -0.002710326 -0.08469594 ...
+        0.08846992 0.4843894 0.4843894 0.08846992 -0.08469594 -0.002710326 ...
+        0.01885659 -0.003809699 ]';
+elseif strcmp(name,'qmf16')
+  kernel = sqrt(2) * [0.001050167 -0.005054526 -0.002589756 0.0276414 -0.009666376 ...
+        -0.09039223 0.09779817 0.4810284 0.4810284 0.09779817 -0.09039223 -0.009666376 ...
+        0.0276414 -0.002589756 -0.005054526 0.001050167 ]';
+elseif strcmp(name,'haar')
+  kernel = [1 1]' / sqrt(2);
+elseif strcmp(name,'daub2')
+  kernel = [0.482962913145 0.836516303738 0.224143868042 -0.129409522551]';
+elseif strcmp(name,'daub3')
+  kernel = [0.332670552950 0.806891509311 0.459877502118 -0.135011020010 ...
+        -0.085441273882  0.035226291882]';
+elseif strcmp(name,'daub4')
+  kernel = [0.230377813309 0.714846570553 0.630880767930 -0.027983769417 ...
+        -0.187034811719 0.030841381836 0.032883011667 -0.010597401785]';
+elseif strcmp(name,'gauss5')  % for backward-compatibility
+  kernel = sqrt(2) * [0.0625 0.25 0.375 0.25 0.0625]';
+elseif strcmp(name,'gauss3')  % for backward-compatibility
+  kernel = sqrt(2) * [0.25 0.5 0.25]';
+else
+  error(sprintf('Bad filter name: %s\n',name));
+end
+  
+% [Johnston80] - J D Johnston, "A filter family designed for use in quadrature 
+%    mirror filter banks", Proc. ICASSP, pp 291-294, 1980.
+%
+% [Daubechies88] - I Daubechies, "Orthonormal bases of compactly supported wavelets",
+%    Commun. Pure Appl. Math, vol. 42, pp 909-996, 1988.
+%
+% [Simoncelli88] - E P Simoncelli,  "Orthogonal sub-band image transforms",
+%     PhD Thesis, MIT Dept. of Elec. Eng. and Comp. Sci. May 1988.
+%     Also available as: MIT Media Laboratory Vision and Modeling Technical 
+%     Report #100.
+%
+% [Simoncelli90] -  E P Simoncelli and E H Adelson, "Subband image coding",
+%    Subband Transforms, chapter 4, ed. John W Woods, Kluwer Academic 
+%    Publishers,  Norwell, MA, 1990, pp 143--192.
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/nextFig.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/nextFig.m
new file mode 100755
index 0000000..e0ac73f
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/nextFig.m
@@ -0,0 +1,19 @@
+% nextFig (MAXFIGS, SKIP)
+% 
+% Make figure number mod((GCF+SKIP), MAXFIGS) the current figure.
+% MAXFIGS is optional, and defaults to 2.
+% SKIP is optional, and defaults to 1.
+
+% Eero Simoncelli, 2/97.
+
+function nextFig(maxfigs, skip)
+
+if (exist('maxfigs') ~= 1)
+  maxfigs = 2;
+end
+  
+if (exist('skip') ~= 1)
+  skip = 1;
+end
+  
+figure(1+mod(gcf-1+skip,maxfigs));
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/pgmRead.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pgmRead.m
new file mode 100755
index 0000000..86c3b62
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pgmRead.m
@@ -0,0 +1,59 @@
+% IM = pgmRead( FILENAME )
+%
+% Load a pgm image into a MatLab matrix.  
+%   This format is accessible from the XV image browsing utility.
+%   Only works for 8bit gray images (raw or ascii)
+
+% Hany Farid, Spring '96.  Modified by Eero Simoncelli, 6/96.
+
+function im = pgmRead( fname );
+
+[fid,msg] = fopen( fname, 'r' );
+
+if (fid == -1)
+  error(msg);
+end
+
+%%% First line contains ID string:
+%%% "P1" = ascii bitmap, "P2" = ascii greymap,
+%%% "P3" = ascii pixmap, "P4" = raw bitmap, 
+%%% "P5" = raw greymap, "P6" = raw pixmap
+TheLine = fgetl(fid);
+format  = TheLine;              
+
+if ~((format(1:2) == 'P2') | (format(1:2) == 'P5'))
+  error('PGM file must be of type P2 or P5');
+end
+
+%%% Any number of comment lines
+TheLine  = fgetl(fid);
+while TheLine(1) == '#' 
+        TheLine = fgetl(fid);
+end
+
+%%% dimensions
+sz = sscanf(TheLine,'%d',2);
+xdim = sz(1);
+ydim = sz(2);
+sz = xdim * ydim;
+
+%%% Maximum pixel value
+TheLine  = fgetl(fid);
+maxval = sscanf(TheLine, '%d',1);
+
+%%im  = zeros(dim,1);
+if (format(2) == '2')
+  [im,count]  = fscanf(fid,'%d',sz);
+else
+  [im,count]  = fread(fid,sz,'uchar');
+end
+
+fclose(fid);
+
+if (count == sz)
+  im = reshape( im, xdim, ydim )';
+else
+  fprintf(1,'Warning: File ended early!');
+  im = reshape( [im ; zeros(sz-count,1)], xdim, ydim)';
+end
+          
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/pgmWrite.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pgmWrite.m
new file mode 100755
index 0000000..09c14c9
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pgmWrite.m
@@ -0,0 +1,120 @@
+% RANGE = pgmWrite(MTX, FILENAME, RANGE, TYPE, COMMENT)
+%
+% Write a MatLab matrix to a pgm (graylevel image) file.
+% This format is accessible from the XV image browsing utility.
+%
+% RANGE (optional) is a 2-vector specifying the values that map to
+% black and white, respectively.  Passing a value of 'auto' (default)
+% sets RANGE=[min,max] (as in MatLab's imagesc).  'auto2' sets
+% RANGE=[mean-2*stdev, mean+2*stdev].  'auto3' sets
+% RANGE=[p1-(p2-p1)/8, p2+(p2-p1)/8], where p1 is the 10th percentile
+% value of the sorted MATRIX samples, and p2 is the 90th percentile
+% value.
+%
+% TYPE (optional) should be 'raw' or 'ascii'.  Defaults to 'raw'.
+
+% Hany Farid,  Spring '96.  Modified by Eero Simoncelli, 6/96.
+
+function range = pgmWrite(mtx, fname, range, type, comment );
+
+[fid,msg] = fopen( fname, 'w' );
+
+if (fid == -1)
+  error(msg);
+end
+
+%------------------------------------------------------------
+%% optional ARGS:
+
+if (exist('range') ~= 1)
+  range = 'auto';
+end
+
+if (exist('type') ~= 1)
+  type = 'raw';
+end
+%------------------------------------------------------------
+
+%% Automatic range calculation: 
+if (strcmp(range,'auto1') | strcmp(range,'auto'))
+  [mn,mx] = range2(mtx);
+  range = [mn,mx];
+
+elseif strcmp(range,'auto2')
+  stdev = sqrt(var2(mtx));
+  av = mean2(mtx);
+  range = [av-2*stdev,av+2*stdev];      % MAGIC NUMBER: 2 stdevs
+
+elseif strcmp(range, 'auto3')
+  percentile = 0.1;                     % MAGIC NUMBER: 0<p<0.5
+  [N,X] = histo(mtx);
+  binsz = X(2)-X(1);
+  N = N+1e-10;  % Ensure cumsum will be monotonic for call to interp1
+  cumN = [0, cumsum(N)]/sum(N);
+  cumX = [X(1)-binsz, X] + (binsz/2);
+  ctrRange = interp1(cumN,cumX, [percentile, 1-percentile]);
+  range = mean(ctrRange) + (ctrRange-mean(ctrRange))/(1-2*percentile);
+
+elseif isstr(range)
+  error(sprintf('Bad RANGE argument: %s',range))
+
+end
+
+if ((range(2) - range(1)) <= eps)
+  range(1) = range(1) - 0.5;
+  range(2) = range(2) + 0.5;
+end
+
+
+%%% First line contains ID string:
+%%% "P1" = ascii bitmap, "P2" = ascii greymap,
+%%% "P3" = ascii pixmap, "P4" = raw bitmap, 
+%%% "P5" = raw greymap, "P6" = raw pixmap
+if strcmp(type,'raw')
+  fprintf(fid,'P5\n');
+  format = 5;
+elseif strcmp(type,'ascii')
+  fprintf(fid,'P2\n');
+  format = 2;
+else
+  error(sprintf('PGMWRITE: Bad type argument: %s',type));
+end
+
+fprintf(fid,'# MatLab PGMWRITE file, saved %s\n',date);
+
+if (exist('comment') == 1)
+  fprintf(fid,'# %s\n', comment);
+end
+
+%%% dimensions
+fprintf(fid,'%d %d\n',size(mtx,2),size(mtx,1));
+
+%%% Maximum pixel value
+fprintf(fid,'255\n');
+
+
+%% MatLab's "fprintf" floors when writing floats, so we compute
+%% (mtx-r1)*255/(r2-r1)+0.5
+mult = (255 / (range(2)-range(1)));
+mtx = (mult * mtx) + (0.5 - mult * range(1));
+
+mtx = max(-0.5+eps,min(255.5-eps,mtx));
+
+if (format == 2)
+  count  = fprintf(fid,'%d ',mtx');
+elseif (format == 5)
+  count  = fwrite(fid,mtx','uchar');
+end
+
+fclose(fid);
+
+if (count ~= size(mtx,1)*size(mtx,2))
+  fprintf(1,'Warning: File output terminated early!');
+end
+          
+%%% TEST:
+% foo = 257*rand(100)-1;
+% pgmWrite(foo,'foo.pgm',[0 255]);
+% foo2=pgmRead('foo.pgm');
+% size(find((foo2-round(foo))~=0))
+% foo(find((foo2-round(foo))~=0))
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/pixelAxes.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pixelAxes.m
new file mode 100755
index 0000000..f88210d
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pixelAxes.m
@@ -0,0 +1,70 @@
+% [ZOOM] = pixelAxes(DIMS, ZOOM)
+%
+% Set the axes of the current plot to cover a multiple of DIMS pixels,
+% thereby eliminating screen aliasing artifacts when displaying an
+% image of size DIMS.  
+% 
+% ZOOM (optional, default='same') expresses the desired number of
+% samples displayed per screen pixel.  It should be a scalar, which
+% will be rounded to the nearest integer, or 1 over an integer.  It
+% may also be the string 'same' or 'auto', in which case the value is chosen so
+% as to produce an image closest in size to the currently displayed
+% image.  It may also be the string 'full', in which case the image is
+% made as large as possible while still fitting in the window.
+
+% Eero Simoncelli, 2/97.
+
+function [zoom] = pixelAxes(dims, zoom)
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('zoom') ~= 1)
+  zoom = 'same';
+end
+
+%% Reverse  dimension order, since Figure Positions reported as (x,y).
+dims = dims(2:-1:1);
+
+%% Use MatLab's axis function to force square pixels, etc:
+axis('image');
+ax = gca;
+
+oldunits = get(ax,'Units');
+
+if strcmp(zoom,'full');
+  set(ax,'Units','normalized');
+  set(ax,'Position',[0 0 1 1]);
+  zoom = 'same';
+end
+
+set(ax,'Units','pixels');
+pos = get(ax,'Position');
+ctr = pos(1:2)+pos(3:4)/2;
+
+if (strcmp(zoom,'same') | strcmp(zoom,'auto'))
+  %% HACK: enlarge slightly so that floor doesn't round down 
+  zoom = min( pos(3:4) ./ (dims - 1) );
+elseif isstr(zoom)
+  error(sprintf('Bad ZOOM argument: %s',zoom));
+end
+
+%% Force zoom value to be an integer, or inverse integer.
+if (zoom < 0.75)
+  zoom = 1/ceil(1/zoom);
+  %% Round upward, subtracting 0.5 to avoid floating point errors.
+  newsz = ceil(zoom*(dims-0.5));
+else
+  zoom = floor(zoom + 0.001);           % Avoid floating pt errors
+  if (zoom < 1.5)                       % zoom=1
+    zoom = 1;
+    newsz = dims + 0.5;
+  else
+    newsz = zoom*(dims-1) + mod(zoom,2);
+  end
+end 
+
+set(ax,'Position', [floor(ctr-newsz/2)+0.5, newsz] )
+
+% Restore units
+set(ax,'Units',oldunits);
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/pointOp.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pointOp.m
new file mode 100755
index 0000000..feb7750
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pointOp.m
@@ -0,0 +1,28 @@
+% RES = pointOp(IM, LUT, ORIGIN, INCREMENT, WARNINGS)
+%
+% Apply a point operation, specified by lookup table LUT, to image IM.
+% LUT must be a row or column vector, and is assumed to contain
+% (equi-spaced) samples of the function.  ORIGIN specifies the
+% abscissa associated with the first sample, and INCREMENT specifies the
+% spacing between samples.  Between-sample values are estimated via
+% linear interpolation.  If WARNINGS is non-zero, the function prints
+% a warning whenever the lookup table is extrapolated.
+%
+% This function is much faster than MatLab's interp1, and allows
+% extrapolation beyond the lookup table domain.  The drawbacks are
+% that the lookup table must be equi-spaced, and the interpolation is
+% linear.
+
+% Eero Simoncelli, 8/96.
+
+function res = pointOp(im, lut, origin, increment, warnings)
+
+%% NOTE: THIS CODE IS NOT ACTUALLY USED! (MEX FILE IS CALLED INSTEAD)
+
+%fprintf(1,'WARNING: You should compile the MEX version of "pointOp.c",\n         found in the MEX subdirectory of matlabPyrTools, and put it in your matlab path.  It is MUCH faster.\n');
+
+X = origin + increment*[0:size(lut(:),1)-1];
+Y = lut(:);
+
+res = reshape(interp1(X, Y, im(:), 'linear', 'extrap'),size(im));
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/pwd2path.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pwd2path.m
new file mode 100755
index 0000000..15aecf0
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pwd2path.m
@@ -0,0 +1,6 @@
+% PWD2PATH()
+%
+% add current working directory (pwd) to path.
+
+P = path;
+path(pwd,P);
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/pyrBand.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pyrBand.m
new file mode 100755
index 0000000..1fb6461
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pyrBand.m
@@ -0,0 +1,11 @@
+% RES = pyrBand(PYR, INDICES, BAND_NUM)
+%
+% Access a subband from a pyramid (gaussian, laplacian, QMF/wavelet, 
+% or steerable).  Subbands are numbered consecutively, from finest
+% (highest spatial frequency) to coarsest (lowest spatial frequency).
+
+% Eero Simoncelli, 6/96.
+
+function res =  pyrBand(pyr, pind, band)
+
+res = reshape( pyr(pyrBandIndices(pind,band)), pind(band,1), pind(band,2) );
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/pyrBandIndices.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pyrBandIndices.m
new file mode 100755
index 0000000..f94c217
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pyrBandIndices.m
@@ -0,0 +1,24 @@
+% RES = pyrBandIndices(INDICES, BAND_NUM)
+%
+% Return indices for accessing a subband from a pyramid 
+% (gaussian, laplacian, QMF/wavelet, steerable).
+
+% Eero Simoncelli, 6/96.
+
+function indices =  pyrBandIndices(pind,band)
+
+if ((band > size(pind,1)) | (band < 1))
+  error(sprintf('BAND_NUM must be between 1 and number of pyramid bands (%d).', ...
+      size(pind,1)));
+end
+
+if (size(pind,2) ~= 2)
+  error('INDICES must be an Nx2 matrix indicating the size of the pyramid subbands');
+end
+
+ind = 1;
+for l=1:band-1
+  ind = ind + prod(pind(l,:));
+end
+
+indices = ind:ind+prod(pind(band,:))-1;
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/pyrLow.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pyrLow.m
new file mode 100755
index 0000000..290e806
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/pyrLow.m
@@ -0,0 +1,12 @@
+% RES = pyrLow(PYR, INDICES)
+%
+% Access the lowpass subband from a pyramid 
+%   (gaussian, laplacian, QMF/wavelet, steerable).
+
+% Eero Simoncelli, 6/96.
+
+function res =  pyrLow(pyr,pind)
+
+band = size(pind,1);
+
+res = reshape( pyr(pyrBandIndices(pind,band)), pind(band,1), pind(band,2) );
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/range2.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/range2.m
new file mode 100755
index 0000000..082bbe1
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/range2.m
@@ -0,0 +1,18 @@
+% [MIN, MAX] = range2(MTX)
+%
+% Compute minimum and maximum values of MTX, returning them as a 2-vector.
+
+% Eero Simoncelli, 3/97.
+
+function [mn, mx] = range2(mtx)
+
+%% NOTE: THIS CODE IS NOT ACTUALLY USED! (MEX FILE IS CALLED INSTEAD)
+
+%fprintf(1,'WARNING: You should compile the MEX version of "range2.c",\n         found in the MEX subdirectory of matlabPyrTools, and put it in your matlab path.  It is MUCH faster.\n');
+
+if (~isreal(mtx))
+  error('MTX must be real-valued');  
+end
+
+mn = min(min(mtx));
+mx = max(max(mtx));
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/rconv2.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/rconv2.m
new file mode 100755
index 0000000..0c12490
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/rconv2.m
@@ -0,0 +1,50 @@
+% RES = RCONV2(MTX1, MTX2, CTR)
+%
+% Convolution of two matrices, with boundaries handled via reflection
+% about the edge pixels.  Result will be of size of LARGER matrix.
+% 
+% The origin of the smaller matrix is assumed to be its center.
+% For even dimensions, the origin is determined by the CTR (optional) 
+% argument:
+%      CTR   origin
+%       0     DIM/2      (default)
+%       1     (DIM/2)+1  
+
+% Eero Simoncelli, 6/96.
+
+function c = rconv2(a,b,ctr)
+
+if (exist('ctr') ~= 1)
+  ctr = 0;
+end
+
+if (( size(a,1) >= size(b,1) ) & ( size(a,2) >= size(b,2) ))
+    large = a; small = b;
+elseif  (( size(a,1) <= size(b,1) ) & ( size(a,2) <= size(b,2) ))
+    large = b; small = a;
+else
+  error('one arg must be larger than the other in both dimensions!');
+end
+
+ly = size(large,1);
+lx = size(large,2);
+sy = size(small,1);
+sx = size(small,2);
+
+%% These values are one less than the index of the small mtx that falls on 
+%% the border pixel of the large matrix when computing the first 
+%% convolution response sample:
+sy2 = floor((sy+ctr-1)/2);
+sx2 = floor((sx+ctr-1)/2);
+
+% pad with reflected copies
+clarge = [ 
+    large(sy-sy2:-1:2,sx-sx2:-1:2), large(sy-sy2:-1:2,:), ...
+        large(sy-sy2:-1:2,lx-1:-1:lx-sx2); ...
+    large(:,sx-sx2:-1:2),    large,   large(:,lx-1:-1:lx-sx2); ...
+    large(ly-1:-1:ly-sy2,sx-sx2:-1:2), ...
+      large(ly-1:-1:ly-sy2,:), ...
+      large(ly-1:-1:ly-sy2,lx-1:-1:lx-sx2) ];
+
+c = conv2(clarge,small,'valid');
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/rcosFn.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/rcosFn.m
new file mode 100755
index 0000000..5dac344
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/rcosFn.m
@@ -0,0 +1,45 @@
+% [X, Y] = rcosFn(WIDTH, POSITION, VALUES)
+%
+% Return a lookup table (suitable for use by INTERP1) 
+% containing a "raised cosine" soft threshold function:
+% 
+%    Y =  VALUES(1) + (VALUES(2)-VALUES(1)) *
+%              cos^2( PI/2 * (X - POSITION + WIDTH)/WIDTH )
+%
+% WIDTH is the width of the region over which the transition occurs
+% (default = 1). POSITION is the location of the center of the
+% threshold (default = 0).  VALUES (default = [0,1]) specifies the
+% values to the left and right of the transition.
+
+% Eero Simoncelli, 7/96.
+
+function [X, Y] = rcosFn(width,position,values)
+
+%------------------------------------------------------------
+% OPTIONAL ARGS:
+
+if (exist('width') ~= 1)
+  width = 1;
+end
+
+if (exist('position') ~= 1)
+  position = 0;
+end
+
+if (exist('values') ~= 1)
+  values = [0,1];
+end
+
+%------------------------------------------------------------
+
+sz = 256;  %% arbitrary!
+
+X    = pi * [-sz-1:1] / (2*sz);
+
+Y = values(1) + (values(2)-values(1)) * cos(X).^2;
+
+%    Make sure end values are repeated, for extrapolation...
+Y(1) = Y(2);
+Y(sz+3) = Y(sz+2);
+
+X = position + (2*width/pi) * (X + pi/4);
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconLpyr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconLpyr.m
new file mode 100755
index 0000000..cddcc12
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconLpyr.m
@@ -0,0 +1,83 @@
+% RES = reconLpyr(PYR, INDICES, LEVS, FILT2, EDGES)
+%
+% Reconstruct image from Laplacian pyramid, as created by buildLpyr.
+%
+% PYR is a vector containing the N pyramid subbands, ordered from fine
+% to coarse.  INDICES is an Nx2 matrix containing the sizes of
+% each subband.  This is compatible with the MatLab Wavelet toolbox.
+%
+% LEVS (optional) should be a list of levels to include, or the string
+% 'all' (default).  The finest scale is number 1.  The lowpass band
+% corresponds to lpyrHt(INDICES)+1.
+%
+% FILT2 (optional) can be a string naming a standard filter (see
+% namedFilter), or a vector which will be used for (separable)
+% convolution.  Default = 'binom5'.  EDGES specifies edge-handling,
+% and defaults to 'reflect1' (see corrDn).
+
+% Eero Simoncelli, 6/96
+
+function res = reconLpyr(pyr, ind, levs, filt2, edges)
+
+if (nargin < 2)
+  error('First two arguments (PYR, INDICES) are required');
+end
+  
+%%------------------------------------------------------------
+%% DEFAULTS:
+
+if (exist('levs') ~= 1)
+  levs = 'all';
+end
+
+if (exist('filt2') ~= 1)
+  filt2 = 'binom5';
+end
+
+if (exist('edges') ~= 1)
+  edges= 'reflect1';
+end
+%%------------------------------------------------------------
+
+maxLev =  1+lpyrHt(ind);
+if strcmp(levs,'all')
+  levs = [1:maxLev]';
+else
+  if (any(levs > maxLev))
+    error(sprintf('Level numbers must be in the range [1, %d].', maxLev));
+  end
+  levs = levs(:);
+end
+
+if isstr(filt2)
+  filt2 = namedFilter(filt2);
+end
+
+filt2 = filt2(:);
+res_sz = ind(1,:);
+
+if any(levs > 1)
+
+  int_sz = [ind(1,1), ind(2,2)];
+  
+  nres = reconLpyr( pyr(prod(res_sz)+1:size(pyr,1)), ...
+      ind(2:size(ind,1),:), levs-1, filt2, edges);
+  
+  if (res_sz(1) == 1)
+    res = upConv(nres, filt2', edges, [1 2], [1 1], res_sz);
+  elseif (res_sz(2) == 1)
+    res = upConv(nres, filt2, edges, [2 1], [1 1], res_sz);
+  else
+    hi = upConv(nres, filt2, edges, [2 1], [1 1], int_sz);
+    res = upConv(hi, filt2', edges, [1 2], [1 1], res_sz);
+  end
+
+else
+  
+  res = zeros(res_sz);
+
+end
+
+if any(levs == 1)
+  res = res + pyrBand(pyr,ind,1);
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSCFpyr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSCFpyr.m
new file mode 100755
index 0000000..a86f03d
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSCFpyr.m
@@ -0,0 +1,87 @@
+% RES = reconSCFpyr(PYR, INDICES, LEVS, BANDS, TWIDTH)
+%
+% The inverse of buildSCFpyr: Reconstruct image from its complex steerable pyramid representation,
+% in the Fourier domain.
+%
+% The image is reconstructed by forcing the complex subbands to be analytic
+% (zero on half of the 2D Fourier plane, as they are supossed to be unless
+% they have being modified), and reconstructing from the real part of those
+% analytic subbands. That is equivalent to compute the Hilbert transforms of
+% the imaginary parts of the subbands, average them with their real
+% counterparts, and then reconstructing from the resulting real subbands.
+%
+% PYR is a vector containing the N pyramid subbands, ordered from fine
+% to coarse.  INDICES is an Nx2 matrix containing the sizes of
+% each subband.  This is compatible with the MatLab Wavelet toolbox.
+%
+% LEVS (optional) should be a list of levels to include, or the string
+% 'all' (default).  0 corresonds to the residual highpass subband.
+% 1 corresponds to the finest oriented scale.  The lowpass band
+% corresponds to number spyrHt(INDICES)+1.
+%
+% BANDS (optional) should be a list of bands to include, or the string
+% 'all' (default).  1 = vertical, rest proceeding anti-clockwise.
+%
+% TWIDTH is the width of the transition region of the radial lowpass
+% function, in octaves (default = 1, which gives a raised cosine for
+% the bandpass filters).
+                                                                                                                        
+% Javier Portilla, 7/04, basing on Eero Simoncelli's Matlab Pyrtools code
+% and our common code on texture synthesis (textureSynthesis.m).
+                                                                                                                        
+function res = reconSCFpyr(pyr, indices, levs, bands, twidth)
+                                                                                                                        
+%%------------------------------------------------------------
+%% DEFAULTS:
+                                                                                                                        
+if ~exist('levs'),
+  levs = 'all';
+end
+                                                                                                                        
+if ~exist('bands')
+  bands = 'all';
+end
+                                                                                                                        
+if ~exist('twidth'),
+  twidth = 1;
+elseif (twidth <= 0)
+  fprintf(1,'Warning: TWIDTH must be positive.  Setting to 1.\n');
+  twidth = 1;
+end
+                                                                                                                        
+%%------------------------------------------------------------
+                                                                                                                        
+                                                                                                                        
+pind = indices;
+Nsc = log2(pind(1,1)/pind(end,1));
+Nor = (size(pind,1)-2)/Nsc;
+                                                                                                                        
+for nsc = 1:Nsc,
+    firstBnum = (nsc-1)*Nor+2;
+                                                                                                                        
+%% Re-create analytic subbands
+    dims = pind(firstBnum,:);
+    ctr = ceil((dims+0.5)/2);
+    ang = mkAngle(dims, 0, ctr);
+    ang(ctr(1),ctr(2)) = -pi/2;
+    for nor = 1:Nor,
+      nband = (nsc-1)*Nor+nor+1;
+      ind = pyrBandIndices(pind,nband);
+      ch = pyrBand(pyr, pind, nband);
+      ang0 = pi*(nor-1)/Nor;
+      xang = mod(ang-ang0+pi, 2*pi) - pi;
+      amask = 2*(abs(xang) < pi/2) + (abs(xang) == pi/2);
+      amask(ctr(1),ctr(2)) = 1;
+      amask(:,1) = 1;
+      amask(1,:) = 1;
+      amask = fftshift(amask);
+      ch = ifft2(amask.*fft2(ch));    % "Analytic" version
+      %f = 1.000008;  % With this factor the reconstruction SNR goes up around 6 dB!
+      f = 1;
+      ch = f*0.5*real(ch); % real part
+      pyr(ind) = ch;
+    end     % nor
+end         % nsc
+                                                                                                                        
+res = reconSFpyr(pyr, indices, levs, bands, twidth);
+                                                                                                                        
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSFpyr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSFpyr.m
new file mode 100755
index 0000000..0e3109e
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSFpyr.m
@@ -0,0 +1,108 @@
+% RES = reconSFpyr(PYR, INDICES, LEVS, BANDS, TWIDTH)
+%
+% Reconstruct image from its steerable pyramid representation, in the Fourier
+% domain, as created by buildSFpyr.
+%
+% PYR is a vector containing the N pyramid subbands, ordered from fine
+% to coarse.  INDICES is an Nx2 matrix containing the sizes of
+% each subband.  This is compatible with the MatLab Wavelet toolbox.
+%
+% LEVS (optional) should be a list of levels to include, or the string
+% 'all' (default).  0 corresonds to the residual highpass subband.  
+% 1 corresponds to the finest oriented scale.  The lowpass band
+% corresponds to number spyrHt(INDICES)+1.
+%
+% BANDS (optional) should be a list of bands to include, or the string
+% 'all' (default).  1 = vertical, rest proceeding anti-clockwise.
+%
+% TWIDTH is the width of the transition region of the radial lowpass
+% function, in octaves (default = 1, which gives a raised cosine for
+% the bandpass filters).
+
+%%% MODIFIED VERSION, 7/04, uses different lookup table for radial frequency!
+
+% Eero Simoncelli, 5/97.
+
+function res = reconSFpyr(pyr, pind, levs, bands, twidth)
+
+%%------------------------------------------------------------
+%% DEFAULTS:
+
+if (exist('levs') ~= 1)
+  levs = 'all';
+end
+
+if (exist('bands') ~= 1)
+  bands = 'all';
+end
+
+if (exist('twidth') ~= 1)
+  twidth = 1;
+elseif (twidth <= 0)
+  fprintf(1,'Warning: TWIDTH must be positive.  Setting to 1.\n');
+  twidth = 1;
+end
+
+%%------------------------------------------------------------
+
+nbands = spyrNumBands(pind);
+
+maxLev =  1+spyrHt(pind);
+if strcmp(levs,'all')
+  levs = [0:maxLev]';
+else
+  if (any(levs > maxLev) | any(levs < 0))
+    error(sprintf('Level numbers must be in the range [0, %d].', maxLev));
+  end
+  levs = levs(:);
+end
+
+if strcmp(bands,'all')
+  bands = [1:nbands]';
+else
+  if (any(bands < 1) | any(bands > nbands))
+    error(sprintf('Band numbers must be in the range [1,3].', nbands));
+  end
+  bands = bands(:);
+end
+
+%----------------------------------------------------------------------
+
+dims = pind(1,:);
+ctr = ceil((dims+0.5)/2);
+
+[xramp,yramp] = meshgrid( ([1:dims(2)]-ctr(2))./(dims(2)/2), ...
+    ([1:dims(1)]-ctr(1))./(dims(1)/2) );
+angle = atan2(yramp,xramp);
+log_rad = sqrt(xramp.^2 + yramp.^2);
+log_rad(ctr(1),ctr(2)) =  log_rad(ctr(1),ctr(2)-1);
+log_rad  = log2(log_rad);
+
+%% Radial transition function (a raised cosine in log-frequency):
+[Xrcos,Yrcos] = rcosFn(twidth,(-twidth/2),[0 1]);
+Yrcos = sqrt(Yrcos);
+YIrcos = sqrt(abs(1.0 - Yrcos.^2));
+
+if (size(pind,1) == 2)
+  if (any(levs==1))
+    resdft = fftshift(fft2(pyrBand(pyr,pind,2)));
+  else
+    resdft = zeros(pind(2,:));
+  end
+else
+  resdft = reconSFpyrLevs(pyr(1+prod(pind(1,:)):size(pyr,1)), ...
+      pind(2:size(pind,1),:), ...
+      log_rad, Xrcos, Yrcos, angle, nbands, levs, bands);
+end
+
+lo0mask = pointOp(log_rad, YIrcos, Xrcos(1), Xrcos(2)-Xrcos(1), 0);
+resdft = resdft .* lo0mask;
+
+%% residual highpass subband
+if any(levs == 0)
+  hi0mask = pointOp(log_rad, Yrcos, Xrcos(1), Xrcos(2)-Xrcos(1), 0);
+  hidft = fftshift(fft2(subMtx(pyr, pind(1,:))));
+  resdft = resdft + hidft .* hi0mask;
+end
+ 
+res = real(ifft2(ifftshift(resdft)));
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSFpyrLevs.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSFpyrLevs.m
new file mode 100755
index 0000000..420f278
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSFpyrLevs.m
@@ -0,0 +1,69 @@
+% RESDFT = reconSFpyrLevs(PYR,INDICES,LOGRAD,XRCOS,YRCOS,ANGLE,NBANDS,LEVS,BANDS)
+%
+% Recursive function for reconstructing levels of a steerable pyramid
+% representation.  This is called by reconSFpyr, and is not usually
+% called directly.
+
+% Eero Simoncelli, 5/97.
+
+function resdft = reconSFpyrLevs(pyr,pind,log_rad,Xrcos,Yrcos,angle,nbands,levs,bands);
+
+lo_ind = nbands+1;
+dims = pind(1,:);
+ctr = ceil((dims+0.5)/2);
+
+%  log_rad = log_rad + 1;
+Xrcos = Xrcos - log2(2);  % shift origin of lut by 1 octave.
+
+if any(levs > 1)
+
+  lodims = ceil((dims-0.5)/2);
+  loctr = ceil((lodims+0.5)/2);
+  lostart = ctr-loctr+1;
+  loend = lostart+lodims-1;
+  nlog_rad = log_rad(lostart(1):loend(1),lostart(2):loend(2));
+  nangle = angle(lostart(1):loend(1),lostart(2):loend(2));
+
+  if  (size(pind,1) > lo_ind)
+    nresdft = reconSFpyrLevs( pyr(1+sum(prod(pind(1:lo_ind-1,:)')):size(pyr,1)),...
+        pind(lo_ind:size(pind,1),:), ...
+        nlog_rad, Xrcos, Yrcos, nangle, nbands,levs-1, bands);
+  else
+    nresdft = fftshift(fft2(pyrBand(pyr,pind,lo_ind)));
+  end
+
+  YIrcos = sqrt(abs(1.0 - Yrcos.^2));
+  lomask = pointOp(nlog_rad, YIrcos, Xrcos(1), Xrcos(2)-Xrcos(1), 0);
+
+  resdft = zeros(dims);
+  resdft(lostart(1):loend(1),lostart(2):loend(2)) = nresdft .* lomask;
+
+else
+
+  resdft = zeros(dims);
+
+end
+
+        
+if any(levs == 1)
+
+  lutsize = 1024;
+  Xcosn = pi*[-(2*lutsize+1):(lutsize+1)]/lutsize;  % [-2*pi:pi]
+  order = nbands-1;
+  %% divide by sqrt(sum_(n=0)^(N-1)  cos(pi*n/N)^(2(N-1)) )
+  const = (2^(2*order))*(factorial(order)^2)/(nbands*factorial(2*order));
+  Ycosn = sqrt(const) * (cos(Xcosn)).^order;
+  himask = pointOp(log_rad, Yrcos, Xrcos(1), Xrcos(2)-Xrcos(1),0);
+
+  ind = 1;
+  for b = 1:nbands
+    if any(bands == b)
+      anglemask = pointOp(angle,Ycosn,Xcosn(1)+pi*(b-1)/nbands,Xcosn(2)-Xcosn(1));
+      band = reshape(pyr(ind:ind+prod(dims)-1), dims(1), dims(2));
+      banddft = fftshift(fft2(band));
+      resdft = resdft + (sqrt(-1))^(nbands-1) * banddft.*anglemask.*himask;
+    end
+    ind = ind + prod(dims);
+  end
+end
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSpyr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSpyr.m
new file mode 100755
index 0000000..270009d
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSpyr.m
@@ -0,0 +1,96 @@
+% RES = reconSpyr(PYR, INDICES, FILTFILE, EDGES, LEVS, BANDS)
+%
+% Reconstruct image from its steerable pyramid representation, as created
+% by buildSpyr.
+%
+% PYR is a vector containing the N pyramid subbands, ordered from fine
+% to coarse.  INDICES is an Nx2 matrix containing the sizes of
+% each subband.  This is compatible with the MatLab Wavelet toolbox.
+%
+% FILTFILE (optional) should be a string referring to an m-file that returns
+% the rfilters.  examples: sp0Filters, sp1Filters, sp3Filters 
+% (default = 'sp1Filters'). 
+% EDGES specifies edge-handling, and defaults to 'reflect1' (see
+% corrDn).
+% 
+% LEVS (optional) should be a list of levels to include, or the string
+% 'all' (default).  0 corresonds to the residual highpass subband.  
+% 1 corresponds to the finest oriented scale.  The lowpass band
+% corresponds to number spyrHt(INDICES)+1.
+%
+% BANDS (optional) should be a list of bands to include, or the string
+% 'all' (default).  1 = vertical, rest proceeding anti-clockwise.
+
+% Eero Simoncelli, 6/96.
+
+function res = reconSpyr(pyr, pind, filtfile, edges, levs, bands)
+
+%%------------------------------------------------------------
+%% DEFAULTS:
+
+if (exist('filtfile') ~= 1)
+  filtfile = 'sp1Filters';
+end
+
+if (exist('edges') ~= 1)
+  edges= 'reflect1';
+end
+
+if (exist('levs') ~= 1)
+  levs = 'all';
+end
+
+if (exist('bands') ~= 1)
+  bands = 'all';
+end
+
+%%------------------------------------------------------------
+
+if (isstr(filtfile) & (exist(filtfile) == 2))
+   [lo0filt,hi0filt,lofilt,bfilts,steermtx,harmonics] = eval(filtfile);
+   nbands = spyrNumBands(pind);
+   if ((nbands > 0) & (size(bfilts,2) ~= nbands))
+     error('Number of pyramid bands is inconsistent with filter file');
+   end
+else
+  error('filtfile argument must be the name of an M-file containing SPYR filters.');
+end
+
+maxLev =  1+spyrHt(pind);
+if strcmp(levs,'all')
+  levs = [0:maxLev]';
+else
+  if (any(levs > maxLev) | any(levs < 0))
+    error(sprintf('Level numbers must be in the range [0, %d].', maxLev));
+  end
+  levs = levs(:);
+end
+
+if strcmp(bands,'all')
+  bands = [1:nbands]';
+else
+  if (any(bands < 1) | any(bands > nbands))
+    error(sprintf('Band numbers must be in the range [1,3].', nbands));
+  end
+  bands = bands(:);
+end
+
+if (spyrHt(pind) == 0)
+  if (any(levs==1))
+    res1 = pyrBand(pyr,pind,2);
+  else
+    res1 = zeros(pind(2,:));
+  end
+else
+  res1 = reconSpyrLevs(pyr(1+prod(pind(1,:)):size(pyr,1)), ...
+      pind(2:size(pind,1),:), ...
+      lofilt, bfilts, edges, levs, bands);
+end
+
+res = upConv(res1, lo0filt, edges);
+
+%% residual highpass subband
+if any(levs == 0)
+   upConv( subMtx(pyr, pind(1,:)), hi0filt, edges, [1 1], [1 1], size(res), res);
+end
+ 
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSpyrLevs.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSpyrLevs.m
new file mode 100755
index 0000000..f8e456c
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconSpyrLevs.m
@@ -0,0 +1,46 @@
+% RES = reconSpyrLevs(PYR,INDICES,LOFILT,BFILTS,EDGES,LEVS,BANDS)
+%
+% Recursive function for reconstructing levels of a steerable pyramid
+% representation.  This is called by reconSpyr, and is not usually
+% called directly.
+
+% Eero Simoncelli, 6/96.
+
+function res = reconSpyrLevs(pyr,pind,lofilt,bfilts,edges,levs,bands);
+
+nbands = size(bfilts,2);
+lo_ind = nbands+1;
+res_sz = pind(1,:);
+
+% Assume square filters:
+bfiltsz =  round(sqrt(size(bfilts,1)));
+
+if any(levs > 1)
+
+  if  (size(pind,1) > lo_ind)
+    nres = reconSpyrLevs( pyr(1+sum(prod(pind(1:lo_ind-1,:)')):size(pyr,1)),  ...
+        pind(lo_ind:size(pind,1),:), ...
+        lofilt, bfilts, edges, levs-1, bands);
+  else
+    nres = pyrBand(pyr,pind,lo_ind);    % lowpass subband
+  end
+
+  res = upConv(nres, lofilt, edges, [2 2], [1 1], res_sz);
+
+else
+
+  res = zeros(res_sz);
+
+end
+        
+if any(levs == 1)
+  ind = 1;
+  for b = 1:nbands
+    if any(bands == b)
+      bfilt = reshape(bfilts(:,b), bfiltsz, bfiltsz);
+      upConv(reshape(pyr(ind:ind+prod(res_sz)-1), res_sz(1), res_sz(2)), ...
+                  bfilt, edges, [1 1], [1 1], res_sz, res);
+    end
+    ind = ind + prod(res_sz);
+  end
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconWpyr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconWpyr.m
new file mode 100755
index 0000000..fc31226
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/reconWpyr.m
@@ -0,0 +1,148 @@
+% RES = reconWpyr(PYR, INDICES, FILT, EDGES, LEVS, BANDS)
+%
+% Reconstruct image from its separable orthonormal QMF/wavelet pyramid
+% representation, as created by buildWpyr.
+%
+% PYR is a vector containing the N pyramid subbands, ordered from fine
+% to coarse.  INDICES is an Nx2 matrix containing the sizes of
+% each subband.  This is compatible with the MatLab Wavelet toolbox.
+%
+% FILT (optional) can be a string naming a standard filter (see
+% namedFilter), or a vector which will be used for (separable)
+% convolution.  Default = 'qmf9'.  EDGES specifies edge-handling,
+% and defaults to 'reflect1' (see corrDn).
+%
+% LEVS (optional) should be a vector of levels to include, or the string
+% 'all' (default).  1 corresponds to the finest scale.  The lowpass band
+% corresponds to wpyrHt(INDICES)+1.
+%
+% BANDS (optional) should be a vector of bands to include, or the string
+% 'all' (default).   1=horizontal, 2=vertical, 3=diagonal.  This is only used
+% for pyramids of 2D images.
+
+% Eero Simoncelli, 6/96.
+
+function res = reconWpyr(pyr, ind, filt, edges, levs, bands)
+
+if (nargin < 2)
+  error('First two arguments (PYR INDICES) are required');
+end
+
+%%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('filt') ~= 1)
+  filt = 'qmf9';
+end
+
+if (exist('edges') ~= 1)
+  edges= 'reflect1';
+end
+
+if (exist('levs') ~= 1)
+  levs = 'all';
+end
+
+if (exist('bands') ~= 1)
+  bands = 'all';
+end
+
+%%------------------------------------------------------------
+
+maxLev = 1+wpyrHt(ind);
+if strcmp(levs,'all')
+  levs = [1:maxLev]';
+else
+  if (any(levs > maxLev))
+    error(sprintf('Level numbers must be in the range [1, %d].', maxLev));
+  end
+  levs = levs(:);
+end
+
+if strcmp(bands,'all')
+  bands = [1:3]';
+else
+  if (any(bands < 1) | any(bands > 3))
+    error('Band numbers must be in the range [1,3].');
+  end
+  bands = bands(:);
+end
+
+if isstr(filt)
+  filt = namedFilter(filt);
+end
+
+filt = filt(:);
+hfilt = modulateFlip(filt);
+
+%% For odd-length filters, stagger the sampling lattices:
+if (mod(size(filt,1),2) == 0)
+        stag = 2;
+else
+        stag = 1;
+end
+
+%% Compute size of result image: assumes critical sampling (boundaries correct)
+res_sz = ind(1,:);
+if (res_sz(1) == 1)
+  loind = 2;
+  res_sz(2) = sum(ind(:,2));
+elseif (res_sz(2) == 1) 
+  loind = 2;
+  res_sz(1) = sum(ind(:,1));
+else
+  loind = 4;
+  res_sz = ind(1,:) + ind(2,:);  %%horizontal + vertical bands.
+  hres_sz = [ind(1,1), res_sz(2)];
+  lres_sz = [ind(2,1), res_sz(2)];
+end
+        
+
+%% First, recursively collapse coarser scales:
+if any(levs > 1)  
+
+  if (size(ind,1) > loind)
+    nres = reconWpyr( pyr(1+sum(prod(ind(1:loind-1,:)')):size(pyr,1)), ...
+        ind(loind:size(ind,1),:), filt, edges, levs-1, bands);
+  else
+    nres = pyrBand(pyr, ind, loind);    % lowpass subband
+  end
+
+  if (res_sz(1) == 1)
+    res = upConv(nres, filt', edges, [1 2], [1 stag], res_sz);
+  elseif (res_sz(2) == 1)
+    res = upConv(nres, filt, edges, [2 1], [stag 1], res_sz);
+  else
+    ires = upConv(nres, filt', edges, [1 2], [1 stag], lres_sz); 
+    res = upConv(ires, filt, edges, [2 1], [stag 1], res_sz);
+  end
+  
+else
+
+  res = zeros(res_sz);
+
+end
+
+        
+%% Add  in reconstructed bands from this level:
+if any(levs == 1)
+  if (res_sz(1) == 1)
+    upConv(pyrBand(pyr,ind,1), hfilt', edges, [1 2], [1 2], res_sz, res);
+  elseif (res_sz(2) == 1)
+    upConv(pyrBand(pyr,ind,1), hfilt, edges, [2 1], [2 1], res_sz, res);
+  else
+    if any(bands == 1) % horizontal
+      ires = upConv(pyrBand(pyr,ind,1),filt',edges,[1 2],[1 stag],hres_sz);
+      upConv(ires,hfilt,edges,[2 1],[2 1],res_sz,res);  %destructively modify res
+    end
+    if any(bands == 2) % vertical
+      ires = upConv(pyrBand(pyr,ind,2),hfilt',edges,[1 2],[1 2],lres_sz);
+      upConv(ires,filt,edges,[2 1],[stag 1],res_sz,res);  %destructively modify res
+    end
+    if any(bands == 3) % diagonal
+      ires =  upConv(pyrBand(pyr,ind,3),hfilt',edges,[1 2],[1 2],hres_sz);
+      upConv(ires,hfilt,edges,[2 1],[2 1],res_sz,res);  %destructively modify res
+    end
+  end
+end
+  
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/script_run_profile.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/script_run_profile.m
new file mode 100755
index 0000000..133ca50
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/script_run_profile.m
@@ -0,0 +1,142 @@
+% Example 2:  Seamless blending of real and synthetic texture in an
+% image, using Portilla-Simoncelli texture analysis/synthesis code,
+% based on alternate projections onto statistical constraints in a
+% complex overcomplete wavelet representation.
+%
+% See Readme.txt, and headers of textureAnalysis.m and
+% textureSynthesis.m for more details.
+%
+% Javier Portilla (javier@decsai.ugr.es).  March, 2001
+
+function script_run_profile(dataDir, resultDir, type, common,toolDir)
+
+path(path, common);
+Files = dir([dataDir,'/1.bmp']);
+inputFile = fullfile(dataDir,Files(1).name);
+
+close all
+
+Nsc = 4; % Number of scales
+Nor = 4; % Number of orientations
+Na = 5;  % Spatial neighborhood is Na x Na coefficients
+                        % It must be an odd number!
+Niter = 25;     % Number of iterations of synthesis loop
+Nsx = 192;      % Size of synthetic image is Nsy x Nsx
+Nsy = 192;      % Warning: both dimensions must be multiple of 2^(Nsc+2)
+
+if(strcmp(type,'qcif'))
+Nsc = 4;
+Nor = 4;
+Na = 5;
+Niter = 5;
+elseif(strcmp(type,'sqcif'))
+Nsc = 2;
+Nor = 2;
+Na = 3;
+Niter = 5;
+elseif(strcmp(type, 'test'))
+Nsc = 2; % Number of scales
+Nor = 2; % Number of orientations
+Na = 1;  % Spatial neighborhood is Na x Na coefficients
+                        % It must be an odd number!
+Niter = 1;      % Number of iterations of synthesis loop
+Nsx = 16;       % Size of synthetic image is Nsy x Nsx
+Nsy = 16;       % Warning: both dimensions must be multiple of 2^(Nsc+2)
+
+elseif(strcmp(type, 'sim_fast'))
+Nsc = 2; % Number of scales
+Nor = 2; % Number of orientations
+Na = 3;  % Spatial neighborhood is Na x Na coefficients
+                        % It must be an odd number!
+Niter = 2;      % Number of iterations of synthesis loop
+Nsx = 16;       % Size of synthetic image is Nsy x Nsx
+Nsy = 16;       % Warning: both dimensions must be multiple of 2^(Nsc+2)
+
+elseif(strcmp(type, 'sim'))
+Nsc = 2; % Number of scales
+Nor = 2; % Number of orientations
+Na = 3;  % Spatial neighborhood is Na x Na coefficients
+                        % It must be an odd number!
+Niter = 1;      % Number of iterations of synthesis loop
+Nsx = 32;       % Size of synthetic image is Nsy x Nsx
+Nsy = 32;       % Warning: both dimensions must be multiple of 2^(Nsc+2)
+
+elseif(strcmp(type, 'vga'))
+Nsc = 2; % Number of scales
+Nor = 2; % Number of orientations
+Na = 3;  % Spatial neighborhood is Na x Na coefficients
+                        % It must be an odd number!
+Niter = 1;      % Number of iterations of synthesis loop
+Nsx = 640;      % Size of synthetic image is Nsy x Nsx
+Nsy = 480;      % Warning: both dimensions must be multiple of 2^(Nsc+2)
+
+elseif(strcmp(type, 'real'))
+Nsc = 2; % Number of scales
+Nor = 2; % Number of orientations
+Na = 3;  % Spatial neighborhood is Na x Na coefficients
+                        % It must be an odd number!
+Niter = 1;      % Number of iterations of synthesis loop
+Nsx = 1920;     % Size of synthetic image is Nsy x Nsx
+Nsy = 1200;     % Warning: both dimensions must be multiple of 2^(Nsc+2)
+
+end
+
+im0 = readImage(inputFile);     % Warning: im0 is a double float matrix!
+rows = size(im0,1);
+cols = size(im0,2);
+fprintf(1,'Input size\t\t- (%dx%d)\n', rows, cols);
+
+%% Self check params
+tol = 0.1;
+elapsed = zeros(1,2);
+
+%% Timing
+start = photonStartTiming;
+
+params = textureAnalysis(im0, Nsc, Nor, Na);
+
+%% Timing
+stop = photonEndTiming;
+
+temp = photonReportTiming(start, stop);
+elapsed(1) = elapsed(1) + temp(1);
+elapsed(2) = elapsed(2) + temp(2);
+
+% Use a mask and the original image to synthesize an image with the
+% left side synthetic and the right side real data.
+% The effective mask is M = (mask>0), its smoothness is for avoiding
+% border effects.
+ramp = meshgrid(1:Nsx/4,1:Nsy)*4/Nsy;
+mask = [zeros(Nsy,Nsx/2) ramp ramp(:,Nsx/4:-1:1)];
+mask =  1/2*(1-cos(pi*mask));
+
+imKeep = zeros(Nsx*Nsy,2);
+imKeep(:,1) = reshape(mask, [Nsy*Nsx,1]);
+imKeep(:,2) = reshape(im0(1:Nsy,1:Nsx), [Nsy*Nsx,1]);   % Original
+
+%% Timing
+start = photonStartTiming;
+
+res = textureSynthesis(params, [Nsy Nsx], Niter,[],imKeep);
+
+%% Timing
+stop = photonEndTiming;
+
+temp = photonReportTiming(start, stop);
+elapsed(1) = elapsed(1) + temp(1);
+elapsed(2) = elapsed(2) + temp(2);
+
+%% Self checking
+fWriteMatrix(res, dataDir);
+
+rows = Nsy;
+cols = Nsx;
+
+%% Timing
+photonPrintTiming(elapsed);
+
+%close all
+%figure(1);showIm(mask>0, 'auto', 'auto', 'Mask');
+%figure(2);showIm(im0, 'auto', 'auto', 'Original Texture');
+%figure(3);showIm(res, 'auto', 'auto', 'Blended Original and Synthetic Texture');
+%pause;
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/script_run_profile1.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/script_run_profile1.m
new file mode 100755
index 0000000..2a7a0dc
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/script_run_profile1.m
@@ -0,0 +1,34 @@
+% Example 1: Synthesis of a "text" texture image, using
+% Portilla-Simoncelli texture analysis/synthesis code, based on
+% alternate projections onto statistical constraints in a complex
+% overcomplete wavelet representation.
+%
+% See Readme.txt, and headers of textureAnalysis.m and
+% textureSynthesis.m for more details.
+%
+% Javier Portilla (javier@decsai.ugr.es).  March, 2001
+
+close all
+
+im0 = imread('/u/kvs/VisionBenchmark/texture_synthesis/result/text.pgm');       % im0 is a double float matrix!
+
+Nsc = 4; % Number of scales
+Nor = 4; % Number of orientations
+Na = 9;  % Spatial neighborhood is Na x Na coefficients
+         % It must be an odd number!
+
+params = textureAnalysis(im0, Nsc, Nor, Na);
+
+Niter = 25;     % Number of iterations of synthesis loop
+Nsx = 192;      % Size of synthetic image is Nsy x Nsx
+Nsy = 128;      % WARNING: Both dimensions must be multiple of 2^(Nsc+2)
+
+res = textureSynthesis(params, [Nsy Nsx], Niter);
+
+close all
+figure(1)
+showIm(im0, 'auto', 1, 'Original texture');
+figure(2)
+showIm(res, 'auto', 1, 'Synthesized texture');
+
+% Can you read the NEW text? ;-)
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/setPyrBand.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/setPyrBand.m
new file mode 100755
index 0000000..baa9f77
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/setPyrBand.m
@@ -0,0 +1,32 @@
+% NEWPYR = setPyrBand(PYR, INDICES, BAND, BAND_NUM)
+%
+% Insert an image (BAND) into a pyramid (gaussian, laplacian, QMF/wavelet, 
+% or steerable).  Subbands are numbered consecutively, from finest
+% (highest spatial frequency) to coarsest (lowest spatial frequency).
+
+% Eero Simoncelli, 1/03.
+
+function pyr =  pyrBand(pyr, pind, band, bandNum)
+
+%% Check: PIND a valid index matrix?
+if ( ~(ndims(pind) == 2) | ~(size(pind,2) == 2) | ~all(pind==round(pind)) )
+  pind
+  error('pyrTools:badArg',...
+      'PIND argument is not an Nbands X 2 matrix of integers');
+end
+
+%% Check: PIND consistent with size of PYR?
+if ( length(pyr) ~= sum(prod(pind,2)) )
+  error('pyrTools:badPyr',...
+      'Pyramid data vector length is inconsistent with index matrix PIND');
+end
+
+%% Check: size of BAND  consistent with desired BANDNUM?
+if (~all(size(band) == pind(bandNum,:)))
+  size(band)
+  pind(bandNum,:)
+  error('pyrTools:badArg',...
+      'size of BAND to be inserted is inconsistent with BAND_NUM');
+end
+
+pyr(pyrBandIndices(pind,bandNum)) = vectify(band); 
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/shift.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/shift.m
new file mode 100755
index 0000000..497297e
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/shift.m
@@ -0,0 +1,15 @@
+% [RES] = shift(MTX, OFFSET)
+% 
+% Circular shift 2D matrix samples by OFFSET (a [Y,X] 2-vector),
+% such that  RES(POS) = MTX(POS-OFFSET).
+
+function res = shift(mtx, offset)
+
+dims = size(mtx);
+
+offset = mod(-offset,dims);
+
+res = [ mtx(offset(1)+1:dims(1), offset(2)+1:dims(2)),  ...
+          mtx(offset(1)+1:dims(1), 1:offset(2));        ...
+        mtx(1:offset(1), offset(2)+1:dims(2)),          ...
+          mtx(1:offset(1), 1:offset(2)) ];
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/showIm.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/showIm.m
new file mode 100755
index 0000000..a9e2bd1
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/showIm.m
@@ -0,0 +1,221 @@
+% RANGE = showIm (MATRIX, RANGE, ZOOM, LABEL, NSHADES )
+% 
+% Display a MatLab MATRIX as a grayscale image in the current figure,
+% inside the current axes.  If MATRIX is complex, the real and imaginary 
+% parts are shown side-by-side, with the same grayscale mapping.
+% 
+% If MATRIX is a string, it should be the name of a variable bound to a 
+% MATRIX in the base (global) environment.  This matrix is displayed as an 
+% image, with the title set to the string.
+% 
+% RANGE (optional) is a 2-vector specifying the values that map to
+% black and white, respectively.  Passing a value of 'auto' (default)
+% sets RANGE=[min,max] (as in MatLab's imagesc).  'auto2' sets
+% RANGE=[mean-2*stdev, mean+2*stdev].  'auto3' sets
+% RANGE=[p1-(p2-p1)/8, p2+(p2-p1)/8], where p1 is the 10th percentile
+% value of the sorted MATRIX samples, and p2 is the 90th percentile
+% value.
+% 
+% ZOOM specifies the number of matrix samples per screen pixel.  It
+% will be rounded to an integer, or 1 divided by an integer.  A value
+% of 'same' or 'auto' (default) causes the zoom value to be chosen
+% automatically to fit the image into the current axes.  A value of
+% 'full' fills the axis region (leaving no room for labels).  See
+% pixelAxes.m.
+% 
+% If LABEL (optional, default = 1, unless zoom='full') is non-zero, the range 
+% of values that are mapped into the gray colormap and the dimensions 
+% (size) of the matrix and zoom factor are printed below the image.  If label 
+% is a string, it is used as a title.
+% 
+% NSHADES (optional) specifies the number of gray shades, and defaults
+% to the size of the current colormap.
+
+% Eero Simoncelli, 6/96.
+
+%%TODO: should use "newplot"
+
+function range = showIm( im, range, zoom, label, nshades );
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (nargin < 1)
+  error('Requires at least one input argument.'); 
+end
+
+MLv = version;
+
+if isstr(im)
+  if (strcmp(MLv(1),'4'))
+    error('Cannot pass string arg for MATRIX in MatLab version 4.x');
+  end
+  label = im;
+  im = evalin('base',im);
+end
+
+if (exist('range') ~= 1)
+  range = 'auto1';
+end
+
+if (exist('nshades') ~= 1)
+  nshades = size(colormap,1);
+end
+nshades = max( nshades, 2 );
+
+if (exist('zoom') ~= 1)
+  zoom = 'auto';
+end
+
+if (exist('label') ~= 1)
+  if strcmp(zoom,'full')
+    label = 0;                          % no labeling
+  else                                  
+    label = 1;                          % just print grayrange & dims
+  end
+end
+
+%------------------------------------------------------------
+
+%% Automatic range calculation: 
+if (strcmp(range,'auto1') | strcmp(range,'auto'))
+  if isreal(im)
+    [mn,mx] = range2(im);
+  else
+    [mn1,mx1] = range2(real(im));
+    [mn2,mx2] =  range2(imag(im));
+    mn = min(mn1,mn2);
+    mx = max(mx1,mx2);
+  end
+  if any(size(im)==1)
+    pad = (mx-mn)/12;                   % MAGIC NUMBER: graph padding
+    range = [mn-pad, mx+pad];
+  else
+    range = [mn,mx];
+  end
+
+elseif strcmp(range,'auto2')
+  if isreal(im)
+    stdev = sqrt(var2(im));
+    av = mean2(im);
+  else
+    stdev = sqrt((var2(real(im)) + var2(imag(im)))/2);
+    av = (mean2(real(im)) + mean2(imag(im)))/2;
+  end
+  range = [av-2*stdev,av+2*stdev];      % MAGIC NUMBER: 2 stdevs
+
+elseif strcmp(range, 'auto3')
+  percentile = 0.1;                     % MAGIC NUMBER: 0<p<0.5
+  [N,X] = histo(im);
+  binsz = X(2)-X(1);
+  N = N+1e-10;  % Ensure cumsum will be monotonic for call to interp1
+  cumN = [0, cumsum(N)]/sum(N);
+  cumX = [X(1)-binsz, X] + (binsz/2);
+  ctrRange = interp1(cumN,cumX, [percentile, 1-percentile]);
+  range = mean(ctrRange) + (ctrRange-mean(ctrRange))/(1-2*percentile);
+
+elseif isstr(range)
+  error(sprintf('Bad RANGE argument: %s',range))
+
+end
+
+if ((range(2) - range(1)) <= eps)
+  range(1) = range(1) - 0.5;
+  range(2) = range(2) + 0.5;
+end
+
+
+if isreal(im)
+  factor=1;
+else
+  factor = 1+sqrt(-1);
+end
+
+xlbl_offset = 0; % default value
+
+if (~any(size(im)==1))
+  %% MatLab's "image" rounds when mapping to the colormap, so we compute
+  %%      (im-r1)*(nshades-1)/(r2-r1) + 1.5 
+  mult = ((nshades-1) / (range(2)-range(1)));
+  d_im = (mult * im) + factor*(1.5 - range(1)*mult);
+end
+
+if isreal(im)
+  if (any(size(im)==1))
+    hh = plot( im);
+    axis([1, prod(size(im)), range]);
+  else
+    hh = image( d_im );
+    axis('off');
+    zoom = pixelAxes(size(d_im),zoom);
+  end
+else
+  if (any(size(im)==1))
+    subplot(2,1,1);
+    hh = plot(real(im));
+    axis([1, prod(size(im)), range]);
+    subplot(2,1,2);
+    hh = plot(imag(im));
+    axis([1, prod(size(im)), range]);
+  else
+    subplot(1,2,1);
+    hh = image(real(d_im));
+    axis('off'); zoom = pixelAxes(size(d_im),zoom);
+    ax = gca; orig_units = get(ax,'Units');
+    set(ax,'Units','points');
+    pos1 = get(ax,'Position');
+    set(ax,'Units',orig_units);
+    subplot(1,2,2);
+    hh = image(imag(d_im));
+    axis('off'); zoom = pixelAxes(size(d_im),zoom);
+    ax = gca; orig_units = get(ax,'Units');
+    set(ax,'Units','points');
+    pos2 = get(ax,'Position');
+    set(ax,'Units',orig_units);
+    xlbl_offset = (pos1(1)-pos2(1))/2;
+  end
+end  
+
+if ~any(size(im)==1)
+  colormap(gray(nshades));
+end
+
+if ((label ~= 0))
+  if isstr(label)
+    title(label);
+    h = get(gca,'Title');
+    orig_units = get(h,'Units');
+    set(h,'Units','points');
+    pos = get(h,'Position');
+    pos(1:2) = pos(1:2) + [xlbl_offset, -3]; % MAGIC NUMBER: y pixel offset
+    set(h,'Position',pos);
+    set(h,'Units',orig_units);
+  end
+
+  if (~any(size(im)==1))
+    if (zoom > 1)
+      zformat = sprintf('* %d',round(zoom));
+    else
+      zformat = sprintf('/ %d',round(1/zoom));
+    end
+    if isreal(im) 
+      format=[' Range: [%.3g, %.3g] \n Dims: [%d, %d] ', zformat];
+        else
+      format=['Range: [%.3g, %.3g]  ----  Dims: [%d, %d]', zformat];
+    end
+    xlabel(sprintf(format, range(1), range(2), size(im,1), size(im,2)));
+    h = get(gca,'Xlabel');
+    set(h,'FontSize', 9);               % MAGIC NUMBER: font size!!!
+
+    orig_units = get(h,'Units');
+    set(h,'Units','points');  
+    pos = get(h,'Position');
+    pos(1:2) = pos(1:2) + [xlbl_offset, 10]; % MAGIC NUMBER: y offset in points
+    set(h,'Position',pos);
+    set(h,'Units',orig_units);
+
+    set(h,'Visible','on');              % axis('image') turned the  xlabel  off...
+  end
+end
+
+return;
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/showLpyr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/showLpyr.m
new file mode 100755
index 0000000..0d85f9d
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/showLpyr.m
@@ -0,0 +1,202 @@
+% RANGE = showLpyr (PYR, INDICES, RANGE, GAP, LEVEL_SCALE_FACTOR)
+% 
+% Display a Laplacian (or Gaussian) pyramid, specified by PYR and
+% INDICES (see buildLpyr), in the current figure.
+% 
+% RANGE is a 2-vector specifying the values that map to black and
+% white, respectively.  These values are scaled by
+% LEVEL_SCALE_FACTOR^(lev-1) for bands at each level.  Passing a value
+% of 'auto1' sets RANGE to the min and max values of MATRIX.  'auto2'
+% sets RANGE to 3 standard deviations below and above 0.0.  In both of
+% these cases, the lowpass band is independently scaled.  A value of
+% 'indep1' sets the range of each subband independently, as in a call
+% to showIm(subband,'auto1').  Similarly, 'indep2' causes each subband
+% to be scaled independently as if by showIm(subband,'indep2').
+% The default value for RANGE is 'auto1' for 1D images, and 'auto2' for
+% 2D images.
+% 
+% GAP (optional, default=1) specifies the gap in pixels to leave
+% between subbands (2D images only).  
+% 
+% LEVEL_SCALE_FACTOR indicates the relative scaling between pyramid
+% levels.  This should be set to the sum of the kernel taps of the
+% lowpass filter used to construct the pyramid (default assumes
+% L2-normalalized filters, using a value of 2 for 2D images, sqrt(2) for
+% 1D images).
+
+% Eero Simoncelli, 2/97.
+
+function [range] = showLpyr(pyr, pind, range, gap, scale);
+
+% Determine 1D or 2D pyramid:
+if ((pind(1,1) == 1) | (pind(1,2) ==1))
+  oned = 1;
+else
+  oned = 0;
+end
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('range') ~= 1)  
+  if (oned==1)
+    range = 'auto1';
+  else
+    range = 'auto2';
+  end
+end
+                
+if (exist('gap') ~= 1)
+  gap = 1;
+end
+
+if (exist('scale') ~= 1)
+  if (oned == 1)
+    scale = sqrt(2);
+  else
+    scale = 2;
+  end
+end
+
+%------------------------------------------------------------
+
+nind = size(pind,1);
+
+%% Auto range calculations:
+if strcmp(range,'auto1')
+  range = zeros(nind,1);
+  mn = 0.0; mx = 0.0;
+  for bnum = 1:(nind-1)
+    band = pyrBand(pyr,pind,bnum)/(scale^(bnum-1));
+    range(bnum) = scale^(bnum-1);
+    [bmn,bmx] = range2(band);
+    mn = min(mn, bmn);  mx = max(mx, bmx);
+  end    
+  if (oned == 1)
+    pad = (mx-mn)/12;                   % *** MAGIC NUMBER!!
+    mn = mn-pad;  mx = mx+pad;
+  end
+  range = range * [mn mx];              % outer product
+  band = pyrLow(pyr,pind);
+  [mn,mx] = range2(band);
+  if (oned == 1)
+    pad = (mx-mn)/12;                   % *** MAGIC NUMBER!!
+    mn = mn-pad;  mx = mx+pad;
+  end
+  range(nind,:) = [mn, mx];
+
+elseif strcmp(range,'indep1')
+  range = zeros(nind,2);
+  for bnum = 1:nind
+    band = pyrBand(pyr,pind,bnum);
+    [mn,mx] = range2(band);
+    if (oned == 1)
+      pad = (mx-mn)/12;                 % *** MAGIC NUMBER!!
+      mn = mn-pad;  mx = mx+pad;
+    end
+    range(bnum,:) =  [mn mx];
+  end
+
+elseif strcmp(range,'auto2')
+  range = zeros(nind,1);
+  sqsum = 0;  numpixels = 0;
+  for bnum = 1:(nind-1)
+    band = pyrBand(pyr,pind,bnum)/(scale^(bnum-1));
+    sqsum = sqsum + sum(sum(band.^2));
+    numpixels = numpixels + prod(size(band));
+    range(bnum) = scale^(bnum-1);
+  end    
+  stdev = sqrt(sqsum/(numpixels-1));
+  range = range * [ -3*stdev 3*stdev ]; % outer product
+  band = pyrLow(pyr,pind);
+  av = mean2(band);   stdev = sqrt(var2(band));
+  range(nind,:) = [av-2*stdev,av+2*stdev];
+
+elseif strcmp(range,'indep2')
+  range = zeros(nind,2);
+  for bnum = 1:(nind-1)
+    band = pyrBand(pyr,pind,bnum);
+    stdev = sqrt(var2(band));
+    range(bnum,:) =  [ -3*stdev 3*stdev ];
+  end
+  band = pyrLow(pyr,pind);
+  av = mean2(band);   stdev = sqrt(var2(band));
+  range(nind,:) = [av-2*stdev,av+2*stdev];
+  
+elseif isstr(range)
+  error(sprintf('Bad RANGE argument: %s',range))
+
+elseif ((size(range,1) == 1) & (size(range,2) == 2))
+  scales = scale.^[0:nind-1];
+  range = scales(:) * range;            % outer product
+  band = pyrLow(pyr,pind);
+  range(nind,:) = range(nind,:) + mean2(band) - mean(range(nind,:));
+
+end
+
+%% Clear Figure
+clf;
+
+if (oned == 1)
+
+  %%%%%  1D signal:
+  for bnum=1:nind
+    band = pyrBand(pyr,pind,bnum);
+    subplot(nind,1,nind-bnum+1);
+    plot(band);
+    axis([1, prod(size(band)), range(bnum,:)]);
+  end
+
+else  
+
+  %%%%% 2D signal:
+  colormap(gray);
+  cmap = get(gcf,'Colormap');
+  nshades = size(cmap,1);
+
+  %  Find background color index:
+  clr = get(gcf,'Color');
+  bg = 1;
+  dist = norm(cmap(bg,:)-clr);
+  for n = 1:nshades
+    ndist = norm(cmap(n,:)-clr);
+    if (ndist < dist)
+      dist = ndist;
+      bg = n;
+    end
+  end  
+
+  %% Compute positions of subbands:
+  llpos = ones(nind,2);
+  dir = [-1 -1];
+  ctr = [pind(1,1)+1+gap 1];
+  sz = [0 0];
+  for bnum = 1:nind
+    prevsz = sz;
+    sz = pind(bnum,:);
+
+    % Determine center position of new band:
+    ctr = ctr + gap*dir/2 + dir.* floor((prevsz+(dir>0))/2);
+    dir = dir * [0 -1; 1 0];  % ccw rotation
+    ctr = ctr + gap*dir/2 + dir.* floor((sz+(dir<0))/2);
+    llpos(bnum,:) = ctr - floor(sz./2);
+  end
+   
+  %% Make position list positive, and allocate appropriate image:
+  llpos = llpos - ones(nind,1)*min(llpos) + 1;
+  urpos = llpos + pind - 1;
+  d_im = bg + zeros(max(urpos));
+
+  %% Paste bands into image, (im-r1)*(nshades-1)/(r2-r1) + 1.5 
+  for bnum=1:nind
+    mult = (nshades-1) / (range(bnum,2)-range(bnum,1));
+    d_im(llpos(bnum,1):urpos(bnum,1), llpos(bnum,2):urpos(bnum,2)) = ...
+        mult*pyrBand(pyr,pind,bnum) + (1.5-mult*range(bnum,1));
+  end
+    
+  hh = image(d_im);
+  axis('off');
+  pixelAxes(size(d_im),'full');
+  set(hh,'UserData',range);
+
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/showSpyr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/showSpyr.m
new file mode 100755
index 0000000..da85715
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/showSpyr.m
@@ -0,0 +1,188 @@
+% RANGE = showSpyr (PYR, INDICES, RANGE, GAP, LEVEL_SCALE_FACTOR)
+% 
+% Display a steerable pyramid, specified by PYR and INDICES
+% (see buildSpyr), in the current figure.  The highpass band is not shown.
+% 
+% RANGE is a 2-vector specifying the values that map to black and
+% white, respectively.  These values are scaled by
+% LEVEL_SCALE_FACTOR^(lev-1) for bands at each level.  Passing a value
+% of 'auto1' sets RANGE to the min and max values of MATRIX.  'auto2'
+% sets RANGE to 3 standard deviations below and above 0.0.  In both of
+% these cases, the lowpass band is independently scaled.  A value of
+% 'indep1' sets the range of each subband independently, as in a call
+% to showIm(subband,'auto1').  Similarly, 'indep2' causes each subband
+% to be scaled independently as if by showIm(subband,'indep2').
+% The default value for RANGE is 'auto2'.
+% 
+% GAP (optional, default=1) specifies the gap in pixels to leave
+% between subbands.  
+% 
+% LEVEL_SCALE_FACTOR indicates the relative scaling between pyramid
+% levels.  This should be set to the sum of the kernel taps of the
+% lowpass filter used to construct the pyramid (default is 2, which is 
+% correct for L2-normalized filters.
+
+% Eero Simoncelli, 2/97.
+
+function [range] = showSpyr(pyr, pind, range, gap, scale);
+
+nbands = spyrNumBands(pind);
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('range') ~= 1)  
+  range = 'auto2';
+end
+                
+if (exist('gap') ~= 1)
+  gap = 1;
+end
+
+if (exist('scale') ~= 1)
+  scale = 2;
+end
+
+%------------------------------------------------------------
+
+ht = spyrHt(pind);
+nind = size(pind,1);
+
+%% Auto range calculations:
+if strcmp(range,'auto1')
+  range = ones(nind,1);
+  band = spyrHigh(pyr,pind);
+  [mn,mx] = range2(band);
+  for lnum = 1:ht
+    for bnum = 1:nbands
+      band = spyrBand(pyr,pind,lnum,bnum)/(scale^(lnum-1));
+      range((lnum-1)*nbands+bnum+1) = scale^(lnum-1);
+      [bmn,bmx] = range2(band);
+      mn = min(mn, bmn);
+      mx = max(mx, bmx);
+    end    
+  end
+  range = range * [mn mx];              % outer product
+  band = pyrLow(pyr,pind);
+  [mn,mx] = range2(band);
+  range(nind,:) = [mn, mx];
+
+elseif strcmp(range,'indep1')
+  range = zeros(nind,2);
+  for bnum = 1:nind
+    band = pyrBand(pyr,pind,bnum);
+    [mn,mx] = range2(band);
+    range(bnum,:) =  [mn mx];
+  end
+
+elseif strcmp(range,'auto2')
+  range = ones(nind,1);
+  band = spyrHigh(pyr,pind);
+  sqsum = sum(sum(band.^2));  numpixels = prod(size(band));
+  for lnum = 1:ht
+    for bnum = 1:nbands
+      band = spyrBand(pyr,pind,lnum,bnum)/(scale^(lnum-1));
+      sqsum = sqsum + sum(sum(band.^2));
+      numpixels = numpixels + prod(size(band));
+      range((lnum-1)*nbands+bnum+1) = scale^(lnum-1);
+    end    
+  end
+  stdev = sqrt(sqsum/(numpixels-1));
+  range = range * [ -3*stdev 3*stdev ]; % outer product
+  band = pyrLow(pyr,pind);
+  av = mean2(band);   stdev = sqrt(var2(band));
+  range(nind,:) = [av-2*stdev,av+2*stdev];
+
+elseif strcmp(range,'indep2')
+  range = zeros(nind,2);
+  for bnum = 1:(nind-1)
+    band = pyrBand(pyr,pind,bnum);
+    stdev = sqrt(var2(band));
+    range(bnum,:) =  [ -3*stdev 3*stdev ];
+  end
+  band = pyrLow(pyr,pind);
+  av = mean2(band);   stdev = sqrt(var2(band));
+  range(nind,:) = [av-2*stdev,av+2*stdev];
+  
+elseif isstr(range)
+  error(sprintf('Bad RANGE argument: %s',range))
+  
+elseif ((size(range,1) == 1) & (size(range,2) == 2))
+  scales = scale.^[0:(ht-1)];
+  scales = ones(nbands,1) * scales;   %outer product
+  scales = [1; scales(:); scale^ht];  %tack on highpass and lowpass
+  range = scales * range;               % outer product
+  band = pyrLow(pyr,pind);
+  range(nind,:) = range(nind,:) + mean2(band) - mean(range(nind,:));
+
+end
+
+% CLEAR FIGURE:
+clf;
+
+colormap(gray);
+cmap = get(gcf,'Colormap');
+nshades = size(cmap,1);
+
+%  Find background color index:
+clr = get(gcf,'Color');
+bg = 1;
+dist = norm(cmap(bg,:)-clr);
+for n = 1:nshades
+  ndist = norm(cmap(n,:)-clr);
+  if (ndist < dist)
+    dist = ndist;
+    bg = n;
+  end
+end  
+
+%% Compute positions of subbands:
+llpos = ones(nind,2);
+
+if (nbands == 2)
+  ncols = 1;  nrows = 2;
+else
+  ncols = ceil((nbands+1)/2);   nrows = ceil(nbands/2);
+end
+relpos = [ (1-nrows):0, zeros(1,(ncols-1)); ...
+           zeros(1,nrows), -1:-1:(1-ncols) ]';
+if (nbands > 1)
+  mvpos = [-1 -1];
+else
+  mvpos = [0 -1];
+end
+basepos = [0 0];
+
+for lnum = 1:ht
+  ind1 = (lnum-1)*nbands + 2;
+  sz = pind(ind1,:)+gap;
+  basepos = basepos + mvpos .* sz;
+  if (nbands < 5)                       % to align edges...
+    sz = sz + gap*(ht-lnum+1);
+  end
+  llpos(ind1:ind1+nbands-1,:) = relpos * diag(sz) + ones(nbands,1)*basepos;
+end
+
+% lowpass band
+sz = pind(nind-1,:)+gap;
+basepos = basepos + mvpos .* sz;
+llpos(nind,:) = basepos;
+
+%% Make position list positive, and allocate appropriate image:
+llpos = llpos - ones(nind,1)*min(llpos) + 1;
+llpos(1,:) = [1 1];
+urpos = llpos + pind - 1;
+d_im = bg + zeros(max(urpos));
+
+%% Paste bands into image, (im-r1)*(nshades-1)/(r2-r1) + 1.5 
+for bnum=2:nind
+  mult = (nshades-1) / (range(bnum,2)-range(bnum,1));
+  d_im(llpos(bnum,1):urpos(bnum,1), llpos(bnum,2):urpos(bnum,2)) = ...
+      mult*pyrBand(pyr,pind,bnum) + (1.5-mult*range(bnum,1));
+end
+  
+hh = image(d_im);
+axis('off');
+pixelAxes(size(d_im),'full');
+set(hh,'UserData',range);
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/showWpyr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/showWpyr.m
new file mode 100755
index 0000000..510e395
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/showWpyr.m
@@ -0,0 +1,204 @@
+% RANGE = showWpyr (PYR, INDICES, RANGE, GAP, LEVEL_SCALE_FACTOR)
+% 
+% Display a separable QMF/wavelet pyramid, specified by PYR and INDICES
+% (see buildWpyr), in the current figure.
+% 
+% RANGE is a 2-vector specifying the values that map to black and
+% white, respectively.  These values are scaled by
+% LEVEL_SCALE_FACTOR^(lev-1) for bands at each level.  Passing a value
+% of 'auto1' sets RANGE to the min and max values of MATRIX.  'auto2'
+% sets RANGE to 3 standard deviations below and above 0.0.  In both of
+% these cases, the lowpass band is independently scaled.  A value of
+% 'indep1' sets the range of each subband independently, as in a call
+% to showIm(subband,'auto1').  Similarly, 'indep2' causes each subband
+% to be scaled independently as if by showIm(subband,'indep2').
+% The default value for RANGE is 'auto1' for 1D images, and 'auto2' for
+% 2D images.
+% 
+% GAP (optional, default=1) specifies the gap in pixels to leave
+% between subbands (2D images only).  
+% 
+% LEVEL_SCALE_FACTOR indicates the relative scaling between pyramid
+% levels.  This should be set to the sum of the kernel taps of the
+% lowpass filter used to construct the pyramid (default assumes
+% L2-normalized filters, using a value of 2 for 2D images, sqrt(2) for
+% 1D images).
+
+% Eero Simoncelli, 2/97.
+
+function [range] = showWpyr(pyr, pind, range, gap, scale);
+
+% Determine 1D or 2D pyramid:
+if ((pind(1,1) == 1) | (pind(1,2) ==1))
+  nbands = 1;
+else
+  nbands = 3;
+end
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('range') ~= 1)  
+  if (nbands==1)
+    range = 'auto1';
+  else
+    range = 'auto2';
+  end
+end
+                
+if (exist('gap') ~= 1)
+  gap = 1;
+end
+
+if (exist('scale') ~= 1)
+  if (nbands == 1)
+    scale = sqrt(2);
+  else
+    scale = 2;
+  end
+end
+
+%------------------------------------------------------------
+
+ht = wpyrHt(pind);
+nind = size(pind,1);
+
+%% Auto range calculations:
+if strcmp(range,'auto1')
+  range = zeros(nind,1);
+  mn = 0.0; mx = 0.0;
+  for lnum = 1:ht
+    for bnum = 1:nbands
+      band = wpyrBand(pyr,pind,lnum,bnum)/(scale^(lnum-1));
+      range((lnum-1)*nbands+bnum) = scale^(lnum-1);
+      [bmn,bmx] = range2(band);
+      mn = min(mn, bmn);  mx = max(mx, bmx);
+    end    
+  end
+  if (nbands == 1)
+    pad = (mx-mn)/12;                   % *** MAGIC NUMBER!!
+    mn = mn-pad;  mx = mx+pad;
+  end
+  range = range * [mn mx];              % outer product
+  band = pyrLow(pyr,pind);
+  [mn,mx] = range2(band);
+  if (nbands == 1)
+    pad = (mx-mn)/12;                   % *** MAGIC NUMBER!!
+    mn = mn-pad;  mx = mx+pad;
+  end
+  range(nind,:) = [mn, mx];
+
+elseif strcmp(range,'indep1')
+  range = zeros(nind,2);
+  for bnum = 1:nind
+    band = pyrBand(pyr,pind,bnum);
+    [mn,mx] = range2(band);
+    if (nbands == 1)
+      pad = (mx-mn)/12;                 % *** MAGIC NUMBER!!
+      mn = mn-pad;  mx = mx+pad;
+    end
+    range(bnum,:) =  [mn mx];
+  end
+
+elseif strcmp(range,'auto2')
+  range = zeros(nind,1);
+  sqsum = 0;  numpixels = 0;
+  for lnum = 1:ht
+    for bnum = 1:nbands
+      band = wpyrBand(pyr,pind,lnum,bnum)/(scale^(lnum-1));
+      sqsum = sqsum + sum(sum(band.^2));
+      numpixels = numpixels + prod(size(band));
+      range((lnum-1)*nbands+bnum) = scale^(lnum-1);
+    end    
+  end
+  stdev = sqrt(sqsum/(numpixels-1));
+  range = range * [ -3*stdev 3*stdev ]; % outer product
+  band = pyrLow(pyr,pind);
+  av = mean2(band);   stdev = sqrt(var2(band));
+  range(nind,:) = [av-2*stdev,av+2*stdev];
+
+elseif strcmp(range,'indep2')
+  range = zeros(nind,2);
+  for bnum = 1:(nind-1)
+    band = pyrBand(pyr,pind,bnum);
+    stdev = sqrt(var2(band));
+    range(bnum,:) =  [ -3*stdev 3*stdev ];
+  end
+  band = pyrLow(pyr,pind);
+  av = mean2(band);   stdev = sqrt(var2(band));
+  range(nind,:) = [av-2*stdev,av+2*stdev];
+  
+elseif isstr(range)
+  error(sprintf('Bad RANGE argument: %s',range))
+  
+elseif ((size(range,1) == 1) & (size(range,2) == 2))
+  scales = scale.^[0:ht];
+  if (nbands ~= 1)
+    scales = [scales; scales; scales];
+  end
+  range = scales(:) * range;            % outer product
+  band = pyrLow(pyr,pind);
+  range(nind,:) = range(nind,:) + mean2(band) - mean(range(nind,:));
+
+end
+
+% CLEAR FIGURE:
+clf;
+
+if (nbands == 1)
+
+  %%%%%  1D signal:
+  for bnum=1:nind
+    band = pyrBand(pyr,pind,bnum);
+    subplot(nind,1,nind-bnum+1);
+    plot(band);
+    axis([1, prod(size(band)), range(bnum,:)]);
+  end
+
+else  
+
+  %%%%% 2D signal:
+  colormap(gray);
+  cmap = get(gcf,'Colormap');
+  nshades = size(cmap,1);
+
+  %  Find background color index:
+  clr = get(gcf,'Color');
+  bg = 1;
+  dist = norm(cmap(bg,:)-clr);
+  for n = 1:nshades
+    ndist = norm(cmap(n,:)-clr);
+    if (ndist < dist)
+      dist = ndist;
+      bg = n;
+    end
+  end  
+
+  %% Compute positions of subbands:
+  llpos = ones(nind,2);
+  for lnum = 1:ht
+    ind1 = nbands*(lnum-1) + 1;
+    xpos = pind(ind1,2) + 1 + gap*(ht-lnum+1);
+    ypos = pind(ind1+1,1) + 1 + gap*(ht-lnum+1);
+    llpos(ind1:ind1+2,:) = [ypos 1; 1 xpos; ypos xpos];
+  end
+  llpos(nind,:) = [1 1];  %lowpass
+
+  %% Make position list positive, and allocate appropriate image:
+  llpos = llpos - ones(nind,1)*min(llpos) + 1;
+  urpos = llpos + pind - 1;
+  d_im = bg + zeros(max(urpos));
+
+  %% Paste bands into image, (im-r1)*(nshades-1)/(r2-r1) + 1.5 
+  for bnum=1:nind
+    mult = (nshades-1) / (range(bnum,2)-range(bnum,1));
+    d_im(llpos(bnum,1):urpos(bnum,1), llpos(bnum,2):urpos(bnum,2)) = ...
+        mult*pyrBand(pyr,pind,bnum) + (1.5-mult*range(bnum,1));
+  end
+    
+  hh = image(d_im);
+  axis('off');
+  pixelAxes(size(d_im),'full');
+  set(hh,'UserData',range);
+
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/shrink.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/shrink.m
new file mode 100755
index 0000000..7af0151
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/shrink.m
@@ -0,0 +1,25 @@
+function ts=shrink(t,f)
+
+% It shrinks an image in a factor f
+% in each dimension. 
+%       ts = shrink(t,f)
+% ts may also be complex.
+% See also: expand.m, blurDn.m
+% JPM, April 95, Instituto de Optica, CSIC, Madrid.
+
+[my,mx]=size(t);
+T=fftshift(fft2(t))/f^2;
+Ts=zeros(my/f,mx/f);
+y1=my/2+2-my/(2*f);
+y2=my/2+my/(2*f);
+x1=mx/2+2-mx/(2*f);
+x2=mx/2+mx/(2*f);
+Ts(2:my/f,2:mx/f)=T(y1:y2,x1:x2);
+Ts(1,2:mx/f)=(T(y1-1,x1:x2)+T(y2+1,x1:x2))/2;
+Ts(2:my/f,1)=(T(y1:y2,x1-1)+T(y1:y2,x2+1))/2;
+Ts(1,1)=(T(y1-1,x1-1)+T(y1-1,x2+1)+T(y2+1,x1-1)+T(y2+1,x2+1))/4;
+Ts=fftshift(Ts);
+ts=ifft2(Ts);
+if all(imag(t)==0),
+        ts = real(ts);
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/skew2.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/skew2.m
new file mode 100755
index 0000000..623d6ca
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/skew2.m
@@ -0,0 +1,21 @@
+% S = SKEW2(MTX,MEAN,VAR)
+%
+% Sample skew (third moment divided by variance^3/2) of a matrix.
+%  MEAN (optional) and VAR (optional) make the computation faster.
+
+function res = skew2(mtx, mn, v)
+
+if (exist('mn') ~= 1)
+  mn =  mean2(mtx);
+end
+
+if (exist('v') ~= 1)
+  v =  var2(mtx,mn);
+end
+
+if (isreal(mtx))
+  res = mean(mean((mtx-mn).^3)) / (v^(3/2));
+else
+  res = mean(mean(real(mtx-mn).^3)) / (real(v)^(3/2)) + ...
+      i * mean(mean(imag(mtx-mn).^3)) / (imag(v)^(3/2));
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/snr.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/snr.m
new file mode 100755
index 0000000..3945d90
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/snr.m
@@ -0,0 +1,10 @@
+function X=SNR(s,n);
+
+% Compute the signal-to-noise ratio in dB
+%       X=SNR(signal,noise);
+% (it does not subtract the means).
+
+es=sum(sum(abs(s).^2))+0.0000001;
+en=sum(sum(abs(n).^2))+0.0000001;
+X=10*log10(es/en);
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/sp0Filters.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/sp0Filters.m
new file mode 100755
index 0000000..6b25e36
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/sp0Filters.m
@@ -0,0 +1,72 @@
+% Steerable pyramid filters.  Transform described  in:
+%
+% @INPROCEEDINGS{Simoncelli95b,
+%       TITLE = "The Steerable Pyramid: A Flexible Architecture for
+%                Multi-Scale Derivative Computation",
+%       AUTHOR = "E P Simoncelli and W T Freeman",
+%       BOOKTITLE = "Second Int'l Conf on Image Processing",
+%       ADDRESS = "Washington, DC", MONTH = "October", YEAR = 1995 }
+%
+% Filter kernel design described in:
+%
+%@INPROCEEDINGS{Karasaridis96,
+%       TITLE = "A Filter Design Technique for 
+%               Steerable Pyramid Image Transforms",
+%       AUTHOR = "A Karasaridis and E P Simoncelli",
+%       BOOKTITLE = "ICASSP",   ADDRESS = "Atlanta, GA",
+%       MONTH = "May",  YEAR = 1996 }
+
+% Eero Simoncelli, 6/96.
+
+function [lo0filt,hi0filt,lofilt,bfilts,mtx,harmonics] = sp0Filters();
+
+harmonics = [ 0 ];
+
+lo0filt = [ ...
+-4.514000e-04 -1.137100e-04 -3.725800e-04 -3.743860e-03 -3.725800e-04 -1.137100e-04 -4.514000e-04
+-1.137100e-04 -6.119520e-03 -1.344160e-02 -7.563200e-03 -1.344160e-02 -6.119520e-03 -1.137100e-04
+-3.725800e-04 -1.344160e-02 6.441488e-02 1.524935e-01 6.441488e-02 -1.344160e-02 -3.725800e-04 
+-3.743860e-03 -7.563200e-03 1.524935e-01 3.153017e-01 1.524935e-01 -7.563200e-03 -3.743860e-03 
+-3.725800e-04 -1.344160e-02 6.441488e-02 1.524935e-01 6.441488e-02 -1.344160e-02 -3.725800e-04 
+-1.137100e-04 -6.119520e-03 -1.344160e-02 -7.563200e-03 -1.344160e-02 -6.119520e-03 -1.137100e-04 
+-4.514000e-04 -1.137100e-04 -3.725800e-04 -3.743860e-03 -3.725800e-04 -1.137100e-04 -4.514000e-04];
+
+lofilt = [ ...
+-2.257000e-04 -8.064400e-04 -5.686000e-05 8.741400e-04 -1.862800e-04 -1.031640e-03 -1.871920e-03 -1.031640e-03 -1.862800e-04 8.741400e-04 -5.686000e-05 -8.064400e-04 -2.257000e-04 
+-8.064400e-04 1.417620e-03 -1.903800e-04 -2.449060e-03 -4.596420e-03 -7.006740e-03 -6.948900e-03 -7.006740e-03 -4.596420e-03 -2.449060e-03 -1.903800e-04 1.417620e-03 -8.064400e-04 
+-5.686000e-05 -1.903800e-04 -3.059760e-03 -6.401000e-03 -6.720800e-03 -5.236180e-03 -3.781600e-03 -5.236180e-03 -6.720800e-03 -6.401000e-03 -3.059760e-03 -1.903800e-04 -5.686000e-05 
+8.741400e-04 -2.449060e-03 -6.401000e-03 -5.260020e-03 3.938620e-03 1.722078e-02 2.449600e-02 1.722078e-02 3.938620e-03 -5.260020e-03 -6.401000e-03 -2.449060e-03 8.741400e-04 
+-1.862800e-04 -4.596420e-03 -6.720800e-03 3.938620e-03 3.220744e-02 6.306262e-02 7.624674e-02 6.306262e-02 3.220744e-02 3.938620e-03 -6.720800e-03 -4.596420e-03 -1.862800e-04 
+-1.031640e-03 -7.006740e-03 -5.236180e-03 1.722078e-02 6.306262e-02 1.116388e-01 1.348999e-01 1.116388e-01 6.306262e-02 1.722078e-02 -5.236180e-03 -7.006740e-03 -1.031640e-03 
+-1.871920e-03 -6.948900e-03 -3.781600e-03 2.449600e-02 7.624674e-02 1.348999e-01 1.576508e-01 1.348999e-01 7.624674e-02 2.449600e-02 -3.781600e-03 -6.948900e-03 -1.871920e-03 
+-1.031640e-03 -7.006740e-03 -5.236180e-03 1.722078e-02 6.306262e-02 1.116388e-01 1.348999e-01 1.116388e-01 6.306262e-02 1.722078e-02 -5.236180e-03 -7.006740e-03 -1.031640e-03 
+-1.862800e-04 -4.596420e-03 -6.720800e-03 3.938620e-03 3.220744e-02 6.306262e-02 7.624674e-02 6.306262e-02 3.220744e-02 3.938620e-03 -6.720800e-03 -4.596420e-03 -1.862800e-04
+8.741400e-04 -2.449060e-03 -6.401000e-03 -5.260020e-03 3.938620e-03 1.722078e-02 2.449600e-02 1.722078e-02 3.938620e-03 -5.260020e-03 -6.401000e-03 -2.449060e-03 8.741400e-04 
+-5.686000e-05 -1.903800e-04 -3.059760e-03 -6.401000e-03 -6.720800e-03 -5.236180e-03 -3.781600e-03 -5.236180e-03 -6.720800e-03 -6.401000e-03 -3.059760e-03 -1.903800e-04 -5.686000e-05 
+-8.064400e-04 1.417620e-03 -1.903800e-04 -2.449060e-03 -4.596420e-03 -7.006740e-03 -6.948900e-03 -7.006740e-03 -4.596420e-03 -2.449060e-03 -1.903800e-04 1.417620e-03 -8.064400e-04 
+-2.257000e-04 -8.064400e-04 -5.686000e-05 8.741400e-04 -1.862800e-04 -1.031640e-03 -1.871920e-03 -1.031640e-03 -1.862800e-04 8.741400e-04 -5.686000e-05 -8.064400e-04 -2.257000e-04]; 
+
+mtx = [ 1.000000 ];
+
+hi0filt = [...
+5.997200e-04 -6.068000e-05 -3.324900e-04 -3.325600e-04 -2.406600e-04 -3.325600e-04 -3.324900e-04 -6.068000e-05 5.997200e-04
+-6.068000e-05 1.263100e-04 4.927100e-04 1.459700e-04 -3.732100e-04 1.459700e-04 4.927100e-04 1.263100e-04 -6.068000e-05 
+-3.324900e-04 4.927100e-04 -1.616650e-03 -1.437358e-02 -2.420138e-02 -1.437358e-02 -1.616650e-03 4.927100e-04 -3.324900e-04 
+-3.325600e-04 1.459700e-04 -1.437358e-02 -6.300923e-02 -9.623594e-02 -6.300923e-02 -1.437358e-02 1.459700e-04 -3.325600e-04 
+-2.406600e-04 -3.732100e-04 -2.420138e-02 -9.623594e-02 8.554893e-01 -9.623594e-02 -2.420138e-02 -3.732100e-04 -2.406600e-04 
+-3.325600e-04 1.459700e-04 -1.437358e-02 -6.300923e-02 -9.623594e-02 -6.300923e-02 -1.437358e-02 1.459700e-04 -3.325600e-04 
+-3.324900e-04 4.927100e-04 -1.616650e-03 -1.437358e-02 -2.420138e-02 -1.437358e-02 -1.616650e-03 4.927100e-04 -3.324900e-04 
+-6.068000e-05 1.263100e-04 4.927100e-04 1.459700e-04 -3.732100e-04 1.459700e-04 4.927100e-04 1.263100e-04 -6.068000e-05 
+5.997200e-04 -6.068000e-05 -3.324900e-04 -3.325600e-04 -2.406600e-04 -3.325600e-04 -3.324900e-04 -6.068000e-05 5.997200e-04 ];
+
+bfilts = [ ...
+-9.066000e-05 -1.738640e-03 -4.942500e-03 -7.889390e-03 -1.009473e-02 -7.889390e-03 -4.942500e-03 -1.738640e-03 -9.066000e-05 ...
+-1.738640e-03 -4.625150e-03 -7.272540e-03 -7.623410e-03 -9.091950e-03 -7.623410e-03 -7.272540e-03 -4.625150e-03 -1.738640e-03 ...
+-4.942500e-03 -7.272540e-03 -2.129540e-02 -2.435662e-02 -3.487008e-02 -2.435662e-02 -2.129540e-02 -7.272540e-03 -4.942500e-03  ...
+-7.889390e-03 -7.623410e-03 -2.435662e-02 -1.730466e-02 -3.158605e-02 -1.730466e-02 -2.435662e-02 -7.623410e-03 -7.889390e-03  ...
+-1.009473e-02 -9.091950e-03 -3.487008e-02 -3.158605e-02 9.464195e-01 -3.158605e-02 -3.487008e-02 -9.091950e-03 -1.009473e-02  ...
+-7.889390e-03 -7.623410e-03 -2.435662e-02 -1.730466e-02 -3.158605e-02 -1.730466e-02 -2.435662e-02 -7.623410e-03 -7.889390e-03 ...
+-4.942500e-03 -7.272540e-03 -2.129540e-02 -2.435662e-02 -3.487008e-02 -2.435662e-02 -2.129540e-02 -7.272540e-03 -4.942500e-03  ...
+-1.738640e-03 -4.625150e-03 -7.272540e-03 -7.623410e-03 -9.091950e-03 -7.623410e-03 -7.272540e-03 -4.625150e-03 -1.738640e-03  ...
+-9.066000e-05 -1.738640e-03 -4.942500e-03 -7.889390e-03 -1.009473e-02 -7.889390e-03 -4.942500e-03 -1.738640e-03 -9.066000e-05 ]';
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/sp1Filters.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/sp1Filters.m
new file mode 100755
index 0000000..215e651
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/sp1Filters.m
@@ -0,0 +1,91 @@
+% Steerable pyramid filters.  Transform described  in:
+%
+% @INPROCEEDINGS{Simoncelli95b,
+%       TITLE = "The Steerable Pyramid: A Flexible Architecture for
+%                Multi-Scale Derivative Computation",
+%       AUTHOR = "E P Simoncelli and W T Freeman",
+%       BOOKTITLE = "Second Int'l Conf on Image Processing",
+%       ADDRESS = "Washington, DC", MONTH = "October", YEAR = 1995 }
+%
+% Filter kernel design described in:
+%
+%@INPROCEEDINGS{Karasaridis96,
+%       TITLE = "A Filter Design Technique for 
+%               Steerable Pyramid Image Transforms",
+%       AUTHOR = "A Karasaridis and E P Simoncelli",
+%       BOOKTITLE = "ICASSP",   ADDRESS = "Atlanta, GA",
+%       MONTH = "May",  YEAR = 1996 }
+
+% Eero Simoncelli, 6/96.
+
+function [lo0filt,hi0filt,lofilt,bfilts,mtx,harmonics] = sp1Filters();
+
+harmonics = [ 1 ];
+
+%% filters only contain first harmonic.
+mtx = eye(2);
+
+lo0filt = [ ...
+-8.701000e-05 -1.354280e-03 -1.601260e-03 -5.033700e-04 2.524010e-03 -5.033700e-04 -1.601260e-03 -1.354280e-03 -8.701000e-05
+-1.354280e-03 2.921580e-03 7.522720e-03 8.224420e-03 1.107620e-03 8.224420e-03 7.522720e-03 2.921580e-03 -1.354280e-03 
+-1.601260e-03 7.522720e-03 -7.061290e-03 -3.769487e-02 -3.297137e-02 -3.769487e-02 -7.061290e-03 7.522720e-03 -1.601260e-03  
+-5.033700e-04 8.224420e-03 -3.769487e-02 4.381320e-02 1.811603e-01 4.381320e-02 -3.769487e-02 8.224420e-03 -5.033700e-04 
+2.524010e-03 1.107620e-03 -3.297137e-02 1.811603e-01 4.376250e-01 1.811603e-01 -3.297137e-02 1.107620e-03 2.524010e-03  
+-5.033700e-04 8.224420e-03 -3.769487e-02 4.381320e-02 1.811603e-01 4.381320e-02 -3.769487e-02 8.224420e-03 -5.033700e-04  
+-1.601260e-03 7.522720e-03 -7.061290e-03 -3.769487e-02 -3.297137e-02 -3.769487e-02 -7.061290e-03 7.522720e-03 -1.601260e-03  
+-1.354280e-03 2.921580e-03 7.522720e-03 8.224420e-03 1.107620e-03 8.224420e-03 7.522720e-03 2.921580e-03 -1.354280e-03  
+-8.701000e-05 -1.354280e-03 -1.601260e-03 -5.033700e-04 2.524010e-03 -5.033700e-04 -1.601260e-03 -1.354280e-03 -8.701000e-05 
+];
+
+lofilt = [ ...
+-4.350000e-05 1.207800e-04 -6.771400e-04 -1.243400e-04 -8.006400e-04 -1.597040e-03 -2.516800e-04 -4.202000e-04 1.262000e-03 -4.202000e-04 -2.516800e-04 -1.597040e-03 -8.006400e-04 -1.243400e-04 -6.771400e-04 1.207800e-04 -4.350000e-05  ; ...
+1.207800e-04 4.460600e-04 -5.814600e-04 5.621600e-04 -1.368800e-04 2.325540e-03 2.889860e-03 4.287280e-03 5.589400e-03 4.287280e-03 2.889860e-03 2.325540e-03 -1.368800e-04 5.621600e-04 -5.814600e-04 4.460600e-04 1.207800e-04  ; ...
+-6.771400e-04 -5.814600e-04 1.460780e-03 2.160540e-03 3.761360e-03 3.080980e-03 4.112200e-03 2.221220e-03 5.538200e-04 2.221220e-03 4.112200e-03 3.080980e-03 3.761360e-03 2.160540e-03 1.460780e-03 -5.814600e-04 -6.771400e-04  ; ...
+-1.243400e-04 5.621600e-04 2.160540e-03 3.175780e-03 3.184680e-03 -1.777480e-03 -7.431700e-03 -9.056920e-03 -9.637220e-03 -9.056920e-03 -7.431700e-03 -1.777480e-03 3.184680e-03 3.175780e-03 2.160540e-03 5.621600e-04 -1.243400e-04  ; ...
+-8.006400e-04 -1.368800e-04 3.761360e-03 3.184680e-03 -3.530640e-03 -1.260420e-02 -1.884744e-02 -1.750818e-02 -1.648568e-02 -1.750818e-02 -1.884744e-02 -1.260420e-02 -3.530640e-03 3.184680e-03 3.761360e-03 -1.368800e-04 -8.006400e-04  ; ...
+-1.597040e-03 2.325540e-03 3.080980e-03 -1.777480e-03 -1.260420e-02 -2.022938e-02 -1.109170e-02 3.955660e-03 1.438512e-02 3.955660e-03 -1.109170e-02 -2.022938e-02 -1.260420e-02 -1.777480e-03 3.080980e-03 2.325540e-03 -1.597040e-03  ; ...
+-2.516800e-04 2.889860e-03 4.112200e-03 -7.431700e-03 -1.884744e-02 -1.109170e-02 2.190660e-02 6.806584e-02 9.058014e-02 6.806584e-02 2.190660e-02 -1.109170e-02 -1.884744e-02 -7.431700e-03 4.112200e-03 2.889860e-03 -2.516800e-04  ; ...
+-4.202000e-04 4.287280e-03 2.221220e-03 -9.056920e-03 -1.750818e-02 3.955660e-03 6.806584e-02 1.445500e-01 1.773651e-01 1.445500e-01 6.806584e-02 3.955660e-03 -1.750818e-02 -9.056920e-03 2.221220e-03 4.287280e-03 -4.202000e-04  ; ...
+1.262000e-03 5.589400e-03 5.538200e-04 -9.637220e-03 -1.648568e-02 1.438512e-02 9.058014e-02 1.773651e-01 2.120374e-01 1.773651e-01 9.058014e-02 1.438512e-02 -1.648568e-02 -9.637220e-03 5.538200e-04 5.589400e-03 1.262000e-03  ; ...
+-4.202000e-04 4.287280e-03 2.221220e-03 -9.056920e-03 -1.750818e-02 3.955660e-03 6.806584e-02 1.445500e-01 1.773651e-01 1.445500e-01 6.806584e-02 3.955660e-03 -1.750818e-02 -9.056920e-03 2.221220e-03 4.287280e-03 -4.202000e-04  ; ...
+-2.516800e-04 2.889860e-03 4.112200e-03 -7.431700e-03 -1.884744e-02 -1.109170e-02 2.190660e-02 6.806584e-02 9.058014e-02 6.806584e-02 2.190660e-02 -1.109170e-02 -1.884744e-02 -7.431700e-03 4.112200e-03 2.889860e-03 -2.516800e-04  ; ...
+-1.597040e-03 2.325540e-03 3.080980e-03 -1.777480e-03 -1.260420e-02 -2.022938e-02 -1.109170e-02 3.955660e-03 1.438512e-02 3.955660e-03 -1.109170e-02 -2.022938e-02 -1.260420e-02 -1.777480e-03 3.080980e-03 2.325540e-03 -1.597040e-03  ; ...
+-8.006400e-04 -1.368800e-04 3.761360e-03 3.184680e-03 -3.530640e-03 -1.260420e-02 -1.884744e-02 -1.750818e-02 -1.648568e-02 -1.750818e-02 -1.884744e-02 -1.260420e-02 -3.530640e-03 3.184680e-03 3.761360e-03 -1.368800e-04 -8.006400e-04  ; ...
+-1.243400e-04 5.621600e-04 2.160540e-03 3.175780e-03 3.184680e-03 -1.777480e-03 -7.431700e-03 -9.056920e-03 -9.637220e-03 -9.056920e-03 -7.431700e-03 -1.777480e-03 3.184680e-03 3.175780e-03 2.160540e-03 5.621600e-04 -1.243400e-04  ; ...
+-6.771400e-04 -5.814600e-04 1.460780e-03 2.160540e-03 3.761360e-03 3.080980e-03 4.112200e-03 2.221220e-03 5.538200e-04 2.221220e-03 4.112200e-03 3.080980e-03 3.761360e-03 2.160540e-03 1.460780e-03 -5.814600e-04 -6.771400e-04  ; ...
+1.207800e-04 4.460600e-04 -5.814600e-04 5.621600e-04 -1.368800e-04 2.325540e-03 2.889860e-03 4.287280e-03 5.589400e-03 4.287280e-03 2.889860e-03 2.325540e-03 -1.368800e-04 5.621600e-04 -5.814600e-04 4.460600e-04 1.207800e-04  ; ...
+-4.350000e-05 1.207800e-04 -6.771400e-04 -1.243400e-04 -8.006400e-04 -1.597040e-03 -2.516800e-04 -4.202000e-04 1.262000e-03 -4.202000e-04 -2.516800e-04 -1.597040e-03 -8.006400e-04 -1.243400e-04 -6.771400e-04 1.207800e-04 -4.350000e-05 ];
+
+hi0filt = [...
+-9.570000e-04 -2.424100e-04 -1.424720e-03 -8.742600e-04 -1.166810e-03 -8.742600e-04 -1.424720e-03 -2.424100e-04 -9.570000e-04 ; ...
+-2.424100e-04 -4.317530e-03 8.998600e-04 9.156420e-03 1.098012e-02 9.156420e-03 8.998600e-04 -4.317530e-03 -2.424100e-04  ; ...
+-1.424720e-03 8.998600e-04 1.706347e-02 1.094866e-02 -5.897780e-03 1.094866e-02 1.706347e-02 8.998600e-04 -1.424720e-03  ; ...
+-8.742600e-04 9.156420e-03 1.094866e-02 -7.841370e-02 -1.562827e-01 -7.841370e-02 1.094866e-02 9.156420e-03 -8.742600e-04  ; ...
+-1.166810e-03 1.098012e-02 -5.897780e-03 -1.562827e-01 7.282593e-01 -1.562827e-01 -5.897780e-03 1.098012e-02 -1.166810e-03  ; ...
+-8.742600e-04 9.156420e-03 1.094866e-02 -7.841370e-02 -1.562827e-01 -7.841370e-02 1.094866e-02 9.156420e-03 -8.742600e-04  ; ...
+-1.424720e-03 8.998600e-04 1.706347e-02 1.094866e-02 -5.897780e-03 1.094866e-02 1.706347e-02 8.998600e-04 -1.424720e-03  ; ...
+-2.424100e-04 -4.317530e-03 8.998600e-04 9.156420e-03 1.098012e-02 9.156420e-03 8.998600e-04 -4.317530e-03 -2.424100e-04  ; ...
+-9.570000e-04 -2.424100e-04 -1.424720e-03 -8.742600e-04 -1.166810e-03 -8.742600e-04 -1.424720e-03 -2.424100e-04 -9.570000e-04 ];
+
+bfilts = -[ ...
+6.125880e-03 -8.052600e-03 -2.103714e-02 -1.536890e-02 -1.851466e-02 -1.536890e-02 -2.103714e-02 -8.052600e-03 6.125880e-03  ...
+-1.287416e-02 -9.611520e-03 1.023569e-02 6.009450e-03 1.872620e-03 6.009450e-03 1.023569e-02 -9.611520e-03 -1.287416e-02  ...
+-5.641530e-03 4.168400e-03 -2.382180e-02 -5.375324e-02 -2.076086e-02 -5.375324e-02 -2.382180e-02 4.168400e-03 -5.641530e-03  ...
+-8.957260e-03 -1.751170e-03 -1.836909e-02 1.265655e-01 2.996168e-01 1.265655e-01 -1.836909e-02 -1.751170e-03 -8.957260e-03  ...
+0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00 0.000000e+00  ...
+8.957260e-03 1.751170e-03 1.836909e-02 -1.265655e-01 -2.996168e-01 -1.265655e-01 1.836909e-02 1.751170e-03 8.957260e-03  ...
+5.641530e-03 -4.168400e-03 2.382180e-02 5.375324e-02 2.076086e-02 5.375324e-02 2.382180e-02 -4.168400e-03 5.641530e-03  ...
+1.287416e-02 9.611520e-03 -1.023569e-02 -6.009450e-03 -1.872620e-03 -6.009450e-03 -1.023569e-02 9.611520e-03 1.287416e-02  ...
+-6.125880e-03 8.052600e-03 2.103714e-02 1.536890e-02 1.851466e-02 1.536890e-02 2.103714e-02 8.052600e-03 -6.125880e-03; ...
+...
+-6.125880e-03 1.287416e-02 5.641530e-03 8.957260e-03 0.000000e+00 -8.957260e-03 -5.641530e-03 -1.287416e-02 6.125880e-03  ...
+8.052600e-03 9.611520e-03 -4.168400e-03 1.751170e-03 0.000000e+00 -1.751170e-03 4.168400e-03 -9.611520e-03 -8.052600e-03  ...
+2.103714e-02 -1.023569e-02 2.382180e-02 1.836909e-02 0.000000e+00 -1.836909e-02 -2.382180e-02 1.023569e-02 -2.103714e-02  ...
+1.536890e-02 -6.009450e-03 5.375324e-02 -1.265655e-01 0.000000e+00 1.265655e-01 -5.375324e-02 6.009450e-03 -1.536890e-02  ...
+1.851466e-02 -1.872620e-03 2.076086e-02 -2.996168e-01 0.000000e+00 2.996168e-01 -2.076086e-02 1.872620e-03 -1.851466e-02  ...
+1.536890e-02 -6.009450e-03 5.375324e-02 -1.265655e-01 0.000000e+00 1.265655e-01 -5.375324e-02 6.009450e-03 -1.536890e-02  ...
+2.103714e-02 -1.023569e-02 2.382180e-02 1.836909e-02 0.000000e+00 -1.836909e-02 -2.382180e-02 1.023569e-02 -2.103714e-02  ...
+8.052600e-03 9.611520e-03 -4.168400e-03 1.751170e-03 0.000000e+00 -1.751170e-03 4.168400e-03 -9.611520e-03 -8.052600e-03  ...
+-6.125880e-03 1.287416e-02 5.641530e-03 8.957260e-03 0.000000e+00 -8.957260e-03 -5.641530e-03 -1.287416e-02 6.125880e-03 ...
+]';
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/sp3Filters.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/sp3Filters.m
new file mode 100755
index 0000000..c9cfaaf
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/sp3Filters.m
@@ -0,0 +1,121 @@
+% Steerable pyramid filters.  Transform described  in:
+%
+% @INPROCEEDINGS{Simoncelli95b,
+%       TITLE = "The Steerable Pyramid: A Flexible Architecture for
+%                Multi-Scale Derivative Computation",
+%       AUTHOR = "E P Simoncelli and W T Freeman",
+%       BOOKTITLE = "Second Int'l Conf on Image Processing",
+%       ADDRESS = "Washington, DC", MONTH = "October", YEAR = 1995 }
+%
+% Filter kernel design described in:
+%
+%@INPROCEEDINGS{Karasaridis96,
+%       TITLE = "A Filter Design Technique for 
+%               Steerable Pyramid Image Transforms",
+%       AUTHOR = "A Karasaridis and E P Simoncelli",
+%       BOOKTITLE = "ICASSP",   ADDRESS = "Atlanta, GA",
+%       MONTH = "May",  YEAR = 1996 }
+
+% Eero Simoncelli, 6/96.
+
+function [lo0filt,hi0filt,lofilt,bfilts,mtx,harmonics] = sp3Filters();
+
+harmonics = [1 3];
+
+mtx = [ ...
+    0.5000    0.3536         0   -0.3536
+   -0.0000    0.3536    0.5000    0.3536
+    0.5000   -0.3536         0    0.3536
+   -0.0000    0.3536   -0.5000    0.3536];
+
+hi0filt = [ 
+-4.0483998600E-4  -6.2596000498E-4  -3.7829999201E-5  8.8387000142E-4  1.5450799838E-3  1.9235999789E-3  2.0687500946E-3  2.0898699295E-3  2.0687500946E-3  1.9235999789E-3  1.5450799838E-3  8.8387000142E-4  -3.7829999201E-5  -6.2596000498E-4  -4.0483998600E-4
+-6.2596000498E-4  -3.2734998967E-4  7.7435001731E-4  1.5874400269E-3  2.1750701126E-3  2.5626500137E-3  2.2892199922E-3  1.9755100366E-3  2.2892199922E-3  2.5626500137E-3  2.1750701126E-3  1.5874400269E-3  7.7435001731E-4  -3.2734998967E-4  -6.2596000498E-4
+-3.7829999201E-5  7.7435001731E-4  1.1793200392E-3  1.4050999889E-3  2.2253401112E-3  2.1145299543E-3  3.3578000148E-4  -8.3368999185E-4  3.3578000148E-4  2.1145299543E-3  2.2253401112E-3  1.4050999889E-3  1.1793200392E-3  7.7435001731E-4  -3.7829999201E-5
+8.8387000142E-4  1.5874400269E-3  1.4050999889E-3  1.2960999738E-3  -4.9274001503E-4  -3.1295299996E-3  -4.5751798898E-3  -5.1014497876E-3  -4.5751798898E-3  -3.1295299996E-3  -4.9274001503E-4  1.2960999738E-3  1.4050999889E-3  1.5874400269E-3  8.8387000142E-4
+1.5450799838E-3  2.1750701126E-3  2.2253401112E-3  -4.9274001503E-4  -6.3222697936E-3  -2.7556000277E-3  5.3632198833E-3  7.3032598011E-3  5.3632198833E-3  -2.7556000277E-3  -6.3222697936E-3  -4.9274001503E-4  2.2253401112E-3  2.1750701126E-3  1.5450799838E-3
+1.9235999789E-3  2.5626500137E-3  2.1145299543E-3  -3.1295299996E-3  -2.7556000277E-3  1.3962360099E-2  7.8046298586E-3  -9.3812197447E-3  7.8046298586E-3  1.3962360099E-2  -2.7556000277E-3  -3.1295299996E-3  2.1145299543E-3  2.5626500137E-3  1.9235999789E-3
+2.0687500946E-3  2.2892199922E-3  3.3578000148E-4  -4.5751798898E-3  5.3632198833E-3  7.8046298586E-3  -7.9501636326E-2  -0.1554141641      -7.9501636326E-2  7.8046298586E-3  5.3632198833E-3  -4.5751798898E-3  3.3578000148E-4  2.2892199922E-3  2.0687500946E-3
+2.0898699295E-3  1.9755100366E-3  -8.3368999185E-4  -5.1014497876E-3  7.3032598011E-3  -9.3812197447E-3  -0.1554141641      0.7303866148      -0.1554141641      -9.3812197447E-3  7.3032598011E-3  -5.1014497876E-3  -8.3368999185E-4  1.9755100366E-3  2.0898699295E-3
+2.0687500946E-3  2.2892199922E-3  3.3578000148E-4  -4.5751798898E-3  5.3632198833E-3  7.8046298586E-3  -7.9501636326E-2  -0.1554141641      -7.9501636326E-2  7.8046298586E-3  5.3632198833E-3  -4.5751798898E-3  3.3578000148E-4  2.2892199922E-3  2.0687500946E-3
+1.9235999789E-3  2.5626500137E-3  2.1145299543E-3  -3.1295299996E-3  -2.7556000277E-3  1.3962360099E-2  7.8046298586E-3  -9.3812197447E-3  7.8046298586E-3  1.3962360099E-2  -2.7556000277E-3  -3.1295299996E-3  2.1145299543E-3  2.5626500137E-3  1.9235999789E-3
+1.5450799838E-3  2.1750701126E-3  2.2253401112E-3  -4.9274001503E-4  -6.3222697936E-3  -2.7556000277E-3  5.3632198833E-3  7.3032598011E-3  5.3632198833E-3  -2.7556000277E-3  -6.3222697936E-3  -4.9274001503E-4  2.2253401112E-3  2.1750701126E-3  1.5450799838E-3
+8.8387000142E-4  1.5874400269E-3  1.4050999889E-3  1.2960999738E-3  -4.9274001503E-4  -3.1295299996E-3  -4.5751798898E-3  -5.1014497876E-3  -4.5751798898E-3  -3.1295299996E-3  -4.9274001503E-4  1.2960999738E-3  1.4050999889E-3  1.5874400269E-3  8.8387000142E-4
+-3.7829999201E-5  7.7435001731E-4  1.1793200392E-3  1.4050999889E-3  2.2253401112E-3  2.1145299543E-3  3.3578000148E-4  -8.3368999185E-4  3.3578000148E-4  2.1145299543E-3  2.2253401112E-3  1.4050999889E-3  1.1793200392E-3  7.7435001731E-4  -3.7829999201E-5
+-6.2596000498E-4  -3.2734998967E-4  7.7435001731E-4  1.5874400269E-3  2.1750701126E-3  2.5626500137E-3  2.2892199922E-3  1.9755100366E-3  2.2892199922E-3  2.5626500137E-3  2.1750701126E-3  1.5874400269E-3  7.7435001731E-4  -3.2734998967E-4  -6.2596000498E-4
+-4.0483998600E-4  -6.2596000498E-4  -3.7829999201E-5  8.8387000142E-4  1.5450799838E-3  1.9235999789E-3  2.0687500946E-3  2.0898699295E-3  2.0687500946E-3  1.9235999789E-3  1.5450799838E-3  8.8387000142E-4  -3.7829999201E-5  -6.2596000498E-4  -4.0483998600E-4
+];
+
+lo0filt = [
+-8.7009997515E-5  -1.3542800443E-3  -1.6012600390E-3  -5.0337001448E-4  2.5240099058E-3  -5.0337001448E-4  -1.6012600390E-3  -1.3542800443E-3  -8.7009997515E-5
+-1.3542800443E-3  2.9215801042E-3  7.5227199122E-3  8.2244202495E-3  1.1076199589E-3  8.2244202495E-3  7.5227199122E-3  2.9215801042E-3  -1.3542800443E-3
+-1.6012600390E-3  7.5227199122E-3  -7.0612900890E-3  -3.7694871426E-2  -3.2971370965E-2  -3.7694871426E-2  -7.0612900890E-3  7.5227199122E-3  -1.6012600390E-3
+-5.0337001448E-4  8.2244202495E-3  -3.7694871426E-2  4.3813198805E-2  0.1811603010      4.3813198805E-2  -3.7694871426E-2  8.2244202495E-3  -5.0337001448E-4
+2.5240099058E-3  1.1076199589E-3  -3.2971370965E-2  0.1811603010      0.4376249909      0.1811603010      -3.2971370965E-2  1.1076199589E-3  2.5240099058E-3
+-5.0337001448E-4  8.2244202495E-3  -3.7694871426E-2  4.3813198805E-2  0.1811603010      4.3813198805E-2  -3.7694871426E-2  8.2244202495E-3  -5.0337001448E-4
+-1.6012600390E-3  7.5227199122E-3  -7.0612900890E-3  -3.7694871426E-2  -3.2971370965E-2  -3.7694871426E-2  -7.0612900890E-3  7.5227199122E-3  -1.6012600390E-3
+-1.3542800443E-3  2.9215801042E-3  7.5227199122E-3  8.2244202495E-3  1.1076199589E-3  8.2244202495E-3  7.5227199122E-3  2.9215801042E-3  -1.3542800443E-3
+-8.7009997515E-5  -1.3542800443E-3  -1.6012600390E-3  -5.0337001448E-4  2.5240099058E-3  -5.0337001448E-4  -1.6012600390E-3  -1.3542800443E-3  -8.7009997515E-5
+];
+
+lofilt = [
+-4.3500000174E-5  1.2078000145E-4  -6.7714002216E-4  -1.2434000382E-4  -8.0063997302E-4  -1.5970399836E-3  -2.5168000138E-4  -4.2019999819E-4  1.2619999470E-3  -4.2019999819E-4  -2.5168000138E-4  -1.5970399836E-3  -8.0063997302E-4  -1.2434000382E-4  -6.7714002216E-4  1.2078000145E-4  -4.3500000174E-5
+1.2078000145E-4  4.4606000301E-4  -5.8146001538E-4  5.6215998484E-4  -1.3688000035E-4  2.3255399428E-3  2.8898599558E-3  4.2872801423E-3  5.5893999524E-3  4.2872801423E-3  2.8898599558E-3  2.3255399428E-3  -1.3688000035E-4  5.6215998484E-4  -5.8146001538E-4  4.4606000301E-4  1.2078000145E-4
+-6.7714002216E-4  -5.8146001538E-4  1.4607800404E-3  2.1605400834E-3  3.7613599561E-3  3.0809799209E-3  4.1121998802E-3  2.2212199401E-3  5.5381999118E-4  2.2212199401E-3  4.1121998802E-3  3.0809799209E-3  3.7613599561E-3  2.1605400834E-3  1.4607800404E-3  -5.8146001538E-4  -6.7714002216E-4
+-1.2434000382E-4  5.6215998484E-4  2.1605400834E-3  3.1757799443E-3  3.1846798956E-3  -1.7774800071E-3  -7.4316998944E-3  -9.0569201857E-3  -9.6372198313E-3  -9.0569201857E-3  -7.4316998944E-3  -1.7774800071E-3  3.1846798956E-3  3.1757799443E-3  2.1605400834E-3  5.6215998484E-4  -1.2434000382E-4
+-8.0063997302E-4  -1.3688000035E-4  3.7613599561E-3  3.1846798956E-3  -3.5306399222E-3  -1.2604200281E-2  -1.8847439438E-2  -1.7508180812E-2  -1.6485679895E-2  -1.7508180812E-2  -1.8847439438E-2  -1.2604200281E-2  -3.5306399222E-3  3.1846798956E-3  3.7613599561E-3  -1.3688000035E-4  -8.0063997302E-4
+-1.5970399836E-3  2.3255399428E-3  3.0809799209E-3  -1.7774800071E-3  -1.2604200281E-2  -2.0229380578E-2  -1.1091699824E-2  3.9556599222E-3  1.4385120012E-2  3.9556599222E-3  -1.1091699824E-2  -2.0229380578E-2  -1.2604200281E-2  -1.7774800071E-3  3.0809799209E-3  2.3255399428E-3  -1.5970399836E-3
+-2.5168000138E-4  2.8898599558E-3  4.1121998802E-3  -7.4316998944E-3  -1.8847439438E-2  -1.1091699824E-2  2.1906599402E-2  6.8065837026E-2  9.0580143034E-2  6.8065837026E-2  2.1906599402E-2  -1.1091699824E-2  -1.8847439438E-2  -7.4316998944E-3  4.1121998802E-3  2.8898599558E-3  -2.5168000138E-4
+-4.2019999819E-4  4.2872801423E-3  2.2212199401E-3  -9.0569201857E-3  -1.7508180812E-2  3.9556599222E-3  6.8065837026E-2  0.1445499808      0.1773651242      0.1445499808      6.8065837026E-2  3.9556599222E-3  -1.7508180812E-2  -9.0569201857E-3  2.2212199401E-3  4.2872801423E-3  -4.2019999819E-4
+1.2619999470E-3  5.5893999524E-3  5.5381999118E-4  -9.6372198313E-3  -1.6485679895E-2  1.4385120012E-2  9.0580143034E-2  0.1773651242      0.2120374441      0.1773651242      9.0580143034E-2  1.4385120012E-2  -1.6485679895E-2  -9.6372198313E-3  5.5381999118E-4  5.5893999524E-3  1.2619999470E-3
+-4.2019999819E-4  4.2872801423E-3  2.2212199401E-3  -9.0569201857E-3  -1.7508180812E-2  3.9556599222E-3  6.8065837026E-2  0.1445499808      0.1773651242      0.1445499808      6.8065837026E-2  3.9556599222E-3  -1.7508180812E-2  -9.0569201857E-3  2.2212199401E-3  4.2872801423E-3  -4.2019999819E-4
+-2.5168000138E-4  2.8898599558E-3  4.1121998802E-3  -7.4316998944E-3  -1.8847439438E-2  -1.1091699824E-2  2.1906599402E-2  6.8065837026E-2  9.0580143034E-2  6.8065837026E-2  2.1906599402E-2  -1.1091699824E-2  -1.8847439438E-2  -7.4316998944E-3  4.1121998802E-3  2.8898599558E-3  -2.5168000138E-4
+-1.5970399836E-3  2.3255399428E-3  3.0809799209E-3  -1.7774800071E-3  -1.2604200281E-2  -2.0229380578E-2  -1.1091699824E-2  3.9556599222E-3  1.4385120012E-2  3.9556599222E-3  -1.1091699824E-2  -2.0229380578E-2  -1.2604200281E-2  -1.7774800071E-3  3.0809799209E-3  2.3255399428E-3  -1.5970399836E-3
+-8.0063997302E-4  -1.3688000035E-4  3.7613599561E-3  3.1846798956E-3  -3.5306399222E-3  -1.2604200281E-2  -1.8847439438E-2  -1.7508180812E-2  -1.6485679895E-2  -1.7508180812E-2  -1.8847439438E-2  -1.2604200281E-2  -3.5306399222E-3  3.1846798956E-3  3.7613599561E-3  -1.3688000035E-4  -8.0063997302E-4
+-1.2434000382E-4  5.6215998484E-4  2.1605400834E-3  3.1757799443E-3  3.1846798956E-3  -1.7774800071E-3  -7.4316998944E-3  -9.0569201857E-3  -9.6372198313E-3  -9.0569201857E-3  -7.4316998944E-3  -1.7774800071E-3  3.1846798956E-3  3.1757799443E-3  2.1605400834E-3  5.6215998484E-4  -1.2434000382E-4
+-6.7714002216E-4  -5.8146001538E-4  1.4607800404E-3  2.1605400834E-3  3.7613599561E-3  3.0809799209E-3  4.1121998802E-3  2.2212199401E-3  5.5381999118E-4  2.2212199401E-3  4.1121998802E-3  3.0809799209E-3  3.7613599561E-3  2.1605400834E-3  1.4607800404E-3  -5.8146001538E-4  -6.7714002216E-4
+1.2078000145E-4  4.4606000301E-4  -5.8146001538E-4  5.6215998484E-4  -1.3688000035E-4  2.3255399428E-3  2.8898599558E-3  4.2872801423E-3  5.5893999524E-3  4.2872801423E-3  2.8898599558E-3  2.3255399428E-3  -1.3688000035E-4  5.6215998484E-4  -5.8146001538E-4  4.4606000301E-4  1.2078000145E-4
+-4.3500000174E-5  1.2078000145E-4  -6.7714002216E-4  -1.2434000382E-4  -8.0063997302E-4  -1.5970399836E-3  -2.5168000138E-4  -4.2019999819E-4  1.2619999470E-3  -4.2019999819E-4  -2.5168000138E-4  -1.5970399836E-3  -8.0063997302E-4  -1.2434000382E-4  -6.7714002216E-4  1.2078000145E-4  -4.3500000174E-5
+];
+
+bfilts = [...
+-8.1125000725E-4  4.4451598078E-3  1.2316980399E-2  1.3955879956E-2  1.4179450460E-2  1.3955879956E-2  1.2316980399E-2  4.4451598078E-3  -8.1125000725E-4 ...
+3.9103501476E-3  4.4565401040E-3  -5.8724298142E-3  -2.8760801069E-3  8.5267601535E-3  -2.8760801069E-3  -5.8724298142E-3  4.4565401040E-3  3.9103501476E-3 ...
+1.3462699717E-3  -3.7740699481E-3  8.2581602037E-3  3.9442278445E-2  5.3605638444E-2  3.9442278445E-2  8.2581602037E-3  -3.7740699481E-3  1.3462699717E-3 ...
+7.4700999539E-4  -3.6522001028E-4  -2.2522680461E-2  -0.1105690673      -0.1768419296      -0.1105690673      -2.2522680461E-2  -3.6522001028E-4  7.4700999539E-4 ...
+0.0000000000      0.0000000000      0.0000000000      0.0000000000      0.0000000000      0.0000000000      0.0000000000      0.0000000000      0.0000000000     ...
+-7.4700999539E-4  3.6522001028E-4  2.2522680461E-2  0.1105690673      0.1768419296      0.1105690673      2.2522680461E-2  3.6522001028E-4  -7.4700999539E-4 ...
+-1.3462699717E-3  3.7740699481E-3  -8.2581602037E-3  -3.9442278445E-2  -5.3605638444E-2  -3.9442278445E-2  -8.2581602037E-3  3.7740699481E-3  -1.3462699717E-3 ...
+-3.9103501476E-3  -4.4565401040E-3  5.8724298142E-3  2.8760801069E-3  -8.5267601535E-3  2.8760801069E-3  5.8724298142E-3  -4.4565401040E-3  -3.9103501476E-3 ...
+8.1125000725E-4  -4.4451598078E-3  -1.2316980399E-2  -1.3955879956E-2  -1.4179450460E-2  -1.3955879956E-2  -1.2316980399E-2  -4.4451598078E-3  8.1125000725E-4; ...
+...
+0.0000000000      -8.2846998703E-4  -5.7109999034E-5  4.0110000555E-5  4.6670897864E-3  8.0871898681E-3  1.4807609841E-2  8.6204400286E-3  -3.1221499667E-3 ...
+8.2846998703E-4  0.0000000000      -9.7479997203E-4  -6.9718998857E-3  -2.0865600090E-3  2.3298799060E-3  -4.4814897701E-3  1.4917500317E-2  8.6204400286E-3 ...
+5.7109999034E-5  9.7479997203E-4  0.0000000000      -1.2145539746E-2  -2.4427289143E-2  5.0797060132E-2  3.2785870135E-2  -4.4814897701E-3  1.4807609841E-2 ...
+-4.0110000555E-5  6.9718998857E-3  1.2145539746E-2  0.0000000000      -0.1510555595      -8.2495503128E-2  5.0797060132E-2  2.3298799060E-3  8.0871898681E-3 ...
+-4.6670897864E-3  2.0865600090E-3  2.4427289143E-2  0.1510555595      0.0000000000      -0.1510555595      -2.4427289143E-2  -2.0865600090E-3  4.6670897864E-3 ...
+-8.0871898681E-3  -2.3298799060E-3  -5.0797060132E-2  8.2495503128E-2  0.1510555595      0.0000000000      -1.2145539746E-2  -6.9718998857E-3  4.0110000555E-5 ...
+-1.4807609841E-2  4.4814897701E-3  -3.2785870135E-2  -5.0797060132E-2  2.4427289143E-2  1.2145539746E-2  0.0000000000      -9.7479997203E-4  -5.7109999034E-5 ...
+-8.6204400286E-3  -1.4917500317E-2  4.4814897701E-3  -2.3298799060E-3  2.0865600090E-3  6.9718998857E-3  9.7479997203E-4  0.0000000000      -8.2846998703E-4 ...
+3.1221499667E-3  -8.6204400286E-3  -1.4807609841E-2  -8.0871898681E-3  -4.6670897864E-3  -4.0110000555E-5  5.7109999034E-5  8.2846998703E-4  0.0000000000; ...
+...
+8.1125000725E-4  -3.9103501476E-3  -1.3462699717E-3  -7.4700999539E-4  0.0000000000      7.4700999539E-4  1.3462699717E-3  3.9103501476E-3  -8.1125000725E-4 ...
+-4.4451598078E-3  -4.4565401040E-3  3.7740699481E-3  3.6522001028E-4  0.0000000000      -3.6522001028E-4  -3.7740699481E-3  4.4565401040E-3  4.4451598078E-3 ...
+-1.2316980399E-2  5.8724298142E-3  -8.2581602037E-3  2.2522680461E-2  0.0000000000      -2.2522680461E-2  8.2581602037E-3  -5.8724298142E-3  1.2316980399E-2 ...
+-1.3955879956E-2  2.8760801069E-3  -3.9442278445E-2  0.1105690673      0.0000000000      -0.1105690673      3.9442278445E-2  -2.8760801069E-3  1.3955879956E-2 ...
+-1.4179450460E-2  -8.5267601535E-3  -5.3605638444E-2  0.1768419296      0.0000000000      -0.1768419296     5.3605638444E-2  8.5267601535E-3  1.4179450460E-2 ...
+-1.3955879956E-2  2.8760801069E-3  -3.9442278445E-2  0.1105690673      0.0000000000      -0.1105690673      3.9442278445E-2  -2.8760801069E-3  1.3955879956E-2 ...
+-1.2316980399E-2  5.8724298142E-3  -8.2581602037E-3  2.2522680461E-2  0.0000000000      -2.2522680461E-2  8.2581602037E-3  -5.8724298142E-3  1.2316980399E-2 ...
+-4.4451598078E-3  -4.4565401040E-3  3.7740699481E-3  3.6522001028E-4  0.0000000000      -3.6522001028E-4  -3.7740699481E-3  4.4565401040E-3  4.4451598078E-3 ...
+8.1125000725E-4  -3.9103501476E-3  -1.3462699717E-3  -7.4700999539E-4  0.0000000000      7.4700999539E-4  1.3462699717E-3  3.9103501476E-3  -8.1125000725E-4; ...
+...
+3.1221499667E-3  -8.6204400286E-3  -1.4807609841E-2  -8.0871898681E-3  -4.6670897864E-3  -4.0110000555E-5  5.7109999034E-5  8.2846998703E-4  0.0000000000  ...   
+-8.6204400286E-3  -1.4917500317E-2  4.4814897701E-3  -2.3298799060E-3  2.0865600090E-3  6.9718998857E-3  9.7479997203E-4  -0.0000000000      -8.2846998703E-4 ...
+-1.4807609841E-2  4.4814897701E-3  -3.2785870135E-2  -5.0797060132E-2  2.4427289143E-2  1.2145539746E-2  0.0000000000      -9.7479997203E-4  -5.7109999034E-5 ...
+-8.0871898681E-3  -2.3298799060E-3  -5.0797060132E-2  8.2495503128E-2  0.1510555595      -0.0000000000      -1.2145539746E-2  -6.9718998857E-3  4.0110000555E-5 ...
+-4.6670897864E-3  2.0865600090E-3  2.4427289143E-2  0.1510555595      0.0000000000      -0.1510555595      -2.4427289143E-2  -2.0865600090E-3  4.6670897864E-3 ...
+-4.0110000555E-5  6.9718998857E-3  1.2145539746E-2  0.0000000000      -0.1510555595      -8.2495503128E-2  5.0797060132E-2  2.3298799060E-3  8.0871898681E-3 ...
+5.7109999034E-5  9.7479997203E-4  -0.0000000000      -1.2145539746E-2  -2.4427289143E-2  5.0797060132E-2  3.2785870135E-2  -4.4814897701E-3  1.4807609841E-2 ...
+8.2846998703E-4  -0.0000000000      -9.7479997203E-4  -6.9718998857E-3  -2.0865600090E-3  2.3298799060E-3  -4.4814897701E-3  1.4917500317E-2  8.6204400286E-3 ...
+0.0000000000      -8.2846998703E-4  -5.7109999034E-5  4.0110000555E-5  4.6670897864E-3  8.0871898681E-3  1.4807609841E-2  8.6204400286E-3  -3.1221499667E-3 ...
+]'; 
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/sp5Filters.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/sp5Filters.m
new file mode 100755
index 0000000..4cddcfd
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/sp5Filters.m
@@ -0,0 +1,110 @@
+% Steerable pyramid filters.  Transform described  in:
+%
+% @INPROCEEDINGS{Simoncelli95b,
+%       TITLE = "The Steerable Pyramid: A Flexible Architecture for
+%                Multi-Scale Derivative Computation",
+%       AUTHOR = "E P Simoncelli and W T Freeman",
+%       BOOKTITLE = "Second Int'l Conf on Image Processing",
+%       ADDRESS = "Washington, DC", MONTH = "October", YEAR = 1995 }
+%
+% Filter kernel design described in:
+%
+%@INPROCEEDINGS{Karasaridis96,
+%       TITLE = "A Filter Design Technique for 
+%               Steerable Pyramid Image Transforms",
+%       AUTHOR = "A Karasaridis and E P Simoncelli",
+%       BOOKTITLE = "ICASSP",   ADDRESS = "Atlanta, GA",
+%       MONTH = "May",  YEAR = 1996 }
+
+% Eero Simoncelli, 6/96.
+
+function [lo0filt,hi0filt,lofilt,bfilts,mtx,harmonics] = sp5Filters();
+
+harmonics = [1 3 5];
+
+mtx = [ ...
+    0.3333    0.2887    0.1667    0.0000   -0.1667   -0.2887
+    0.0000    0.1667    0.2887    0.3333    0.2887    0.1667
+    0.3333   -0.0000   -0.3333   -0.0000    0.3333   -0.0000
+    0.0000    0.3333    0.0000   -0.3333    0.0000    0.3333
+    0.3333   -0.2887    0.1667   -0.0000   -0.1667    0.2887
+   -0.0000    0.1667   -0.2887    0.3333   -0.2887    0.1667];
+
+hi0filt = [ 
+-0.00033429 -0.00113093 -0.00171484 -0.00133542 -0.00080639 -0.00133542 -0.00171484 -0.00113093 -0.00033429
+-0.00113093 -0.00350017 -0.00243812 0.00631653 0.01261227 0.00631653 -0.00243812 -0.00350017 -0.00113093
+-0.00171484 -0.00243812 -0.00290081 -0.00673482 -0.00981051 -0.00673482 -0.00290081 -0.00243812 -0.00171484
+-0.00133542 0.00631653 -0.00673482 -0.07027679 -0.11435863 -0.07027679 -0.00673482 0.00631653 -0.00133542
+-0.00080639 0.01261227 -0.00981051 -0.11435863 0.81380200 -0.11435863 -0.00981051 0.01261227 -0.00080639
+-0.00133542 0.00631653 -0.00673482 -0.07027679 -0.11435863 -0.07027679 -0.00673482 0.00631653 -0.00133542
+-0.00171484 -0.00243812 -0.00290081 -0.00673482 -0.00981051 -0.00673482 -0.00290081 -0.00243812 -0.00171484
+-0.00113093 -0.00350017 -0.00243812 0.00631653 0.01261227 0.00631653 -0.00243812 -0.00350017 -0.00113093
+-0.00033429 -0.00113093 -0.00171484 -0.00133542 -0.00080639 -0.00133542 -0.00171484 -0.00113093 -0.00033429];
+
+
+lo0filt = [
+0.00341614 -0.01551246 -0.03848215 -0.01551246 0.00341614
+-0.01551246 0.05586982 0.15925570 0.05586982 -0.01551246
+-0.03848215 0.15925570 0.40304148 0.15925570 -0.03848215
+-0.01551246 0.05586982 0.15925570 0.05586982 -0.01551246
+0.00341614 -0.01551246 -0.03848215 -0.01551246 0.00341614];
+
+lofilt = 2*[
+0.00085404 -0.00244917 -0.00387812 -0.00944432 -0.00962054 -0.00944432 -0.00387812 -0.00244917 0.00085404
+-0.00244917 -0.00523281 -0.00661117 0.00410600 0.01002988 0.00410600 -0.00661117 -0.00523281 -0.00244917
+-0.00387812 -0.00661117 0.01396746 0.03277038 0.03981393 0.03277038 0.01396746 -0.00661117 -0.00387812
+-0.00944432 0.00410600 0.03277038 0.06426333 0.08169618 0.06426333 0.03277038 0.00410600 -0.00944432
+-0.00962054 0.01002988 0.03981393 0.08169618 0.10096540 0.08169618 0.03981393 0.01002988 -0.00962054
+-0.00944432 0.00410600 0.03277038 0.06426333 0.08169618 0.06426333 0.03277038 0.00410600 -0.00944432
+-0.00387812 -0.00661117 0.01396746 0.03277038 0.03981393 0.03277038 0.01396746 -0.00661117 -0.00387812
+-0.00244917 -0.00523281 -0.00661117 0.00410600 0.01002988 0.00410600 -0.00661117 -0.00523281 -0.00244917
+0.00085404 -0.00244917 -0.00387812 -0.00944432 -0.00962054 -0.00944432 -0.00387812 -0.00244917 0.00085404];
+
+bfilts = [...
+ 0.00277643 0.00496194 0.01026699 0.01455399 0.01026699 0.00496194 0.00277643 ...
+-0.00986904 -0.00893064 0.01189859 0.02755155 0.01189859 -0.00893064 -0.00986904 ...
+-0.01021852 -0.03075356 -0.08226445 -0.11732297 -0.08226445 -0.03075356 -0.01021852 ...
+ 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 ...
+ 0.01021852 0.03075356 0.08226445 0.11732297 0.08226445 0.03075356 0.01021852 ...
+ 0.00986904 0.00893064 -0.01189859 -0.02755155 -0.01189859 0.00893064 0.00986904 ...
+-0.00277643 -0.00496194 -0.01026699 -0.01455399 -0.01026699 -0.00496194 -0.00277643;
+...
+-0.00343249 -0.00640815 -0.00073141 0.01124321 0.00182078 0.00285723 0.01166982 ...
+-0.00358461 -0.01977507 -0.04084211 -0.00228219 0.03930573 0.01161195 0.00128000 ...
+ 0.01047717 0.01486305 -0.04819057 -0.12227230 -0.05394139 0.00853965 -0.00459034 ...
+ 0.00790407 0.04435647 0.09454202 -0.00000000 -0.09454202 -0.04435647 -0.00790407 ...
+ 0.00459034 -0.00853965 0.05394139 0.12227230 0.04819057 -0.01486305 -0.01047717 ...
+-0.00128000 -0.01161195 -0.03930573 0.00228219 0.04084211 0.01977507 0.00358461 ...
+-0.01166982 -0.00285723 -0.00182078 -0.01124321 0.00073141 0.00640815 0.00343249;
+...
+ 0.00343249 0.00358461 -0.01047717 -0.00790407 -0.00459034 0.00128000 0.01166982 ...
+ 0.00640815 0.01977507 -0.01486305 -0.04435647 0.00853965 0.01161195 0.00285723 ...
+ 0.00073141 0.04084211 0.04819057 -0.09454202 -0.05394139 0.03930573 0.00182078 ...
+-0.01124321 0.00228219 0.12227230 -0.00000000 -0.12227230 -0.00228219 0.01124321 ...
+-0.00182078 -0.03930573 0.05394139 0.09454202 -0.04819057 -0.04084211 -0.00073141 ...
+-0.00285723 -0.01161195 -0.00853965 0.04435647 0.01486305 -0.01977507 -0.00640815 ...
+-0.01166982 -0.00128000 0.00459034 0.00790407 0.01047717 -0.00358461 -0.00343249;
+...
+-0.00277643 0.00986904 0.01021852 -0.00000000 -0.01021852 -0.00986904 0.00277643 ...
+-0.00496194 0.00893064 0.03075356 -0.00000000 -0.03075356 -0.00893064 0.00496194 ...
+-0.01026699 -0.01189859 0.08226445 -0.00000000 -0.08226445 0.01189859 0.01026699 ...
+-0.01455399 -0.02755155 0.11732297 -0.00000000 -0.11732297 0.02755155 0.01455399 ...
+-0.01026699 -0.01189859 0.08226445 -0.00000000 -0.08226445 0.01189859 0.01026699 ...
+-0.00496194 0.00893064 0.03075356 -0.00000000 -0.03075356 -0.00893064 0.00496194 ...
+-0.00277643 0.00986904 0.01021852 -0.00000000 -0.01021852 -0.00986904 0.00277643;
+...
+-0.01166982 -0.00128000 0.00459034 0.00790407 0.01047717 -0.00358461 -0.00343249 ...
+-0.00285723 -0.01161195 -0.00853965 0.04435647 0.01486305 -0.01977507 -0.00640815 ...
+-0.00182078 -0.03930573 0.05394139 0.09454202 -0.04819057 -0.04084211 -0.00073141 ...
+-0.01124321 0.00228219 0.12227230 -0.00000000 -0.12227230 -0.00228219 0.01124321 ...
+ 0.00073141 0.04084211 0.04819057 -0.09454202 -0.05394139 0.03930573 0.00182078 ...
+ 0.00640815 0.01977507 -0.01486305 -0.04435647 0.00853965 0.01161195 0.00285723 ...
+ 0.00343249 0.00358461 -0.01047717 -0.00790407 -0.00459034 0.00128000 0.01166982;
+...
+-0.01166982 -0.00285723 -0.00182078 -0.01124321 0.00073141 0.00640815 0.00343249 ...
+-0.00128000 -0.01161195 -0.03930573 0.00228219 0.04084211 0.01977507 0.00358461 ...
+ 0.00459034 -0.00853965 0.05394139 0.12227230 0.04819057 -0.01486305 -0.01047717 ...
+ 0.00790407 0.04435647 0.09454202 -0.00000000 -0.09454202 -0.04435647 -0.00790407 ...
+ 0.01047717 0.01486305 -0.04819057 -0.12227230 -0.05394139 0.00853965 -0.00459034 ...
+-0.00358461 -0.01977507 -0.04084211 -0.00228219 0.03930573 0.01161195 0.00128000 ...
+-0.00343249 -0.00640815 -0.00073141 0.01124321 0.00182078 0.00285723 0.01166982]'; 
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrBand.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrBand.m
new file mode 100755
index 0000000..474a8dc
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrBand.m
@@ -0,0 +1,34 @@
+% [LEV,IND] = spyrBand(PYR,INDICES,LEVEL,BAND)
+%
+% Access a band from a steerable pyramid.
+% 
+%   LEVEL indicates the scale (finest = 1, coarsest = spyrHt(INDICES)).
+% 
+%   BAND (optional, default=1) indicates which subband 
+%     (1 = vertical, rest proceeding anti-clockwise).
+
+% Eero Simoncelli, 6/96.
+
+function res =  spyrBand(pyr,pind,level,band)
+
+if (exist('level') ~= 1)
+  level = 1;
+end
+
+if (exist('band') ~= 1)
+  band = 1;
+end
+
+nbands = spyrNumBands(pind);
+if ((band > nbands) | (band < 1))
+  error(sprintf('Bad band number (%d) should be in range [1,%d].', band, nbands));
+end     
+
+maxLev = spyrHt(pind);
+if ((level > maxLev) | (level < 1))
+  error(sprintf('Bad level number (%d), should be in range [1,%d].', level, maxLev));
+end
+
+firstband = 1 + band + nbands*(level-1);
+res  = pyrBand(pyr, pind, firstband);
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrHigh.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrHigh.m
new file mode 100755
index 0000000..f91b466
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrHigh.m
@@ -0,0 +1,10 @@
+% RES = spyrHigh(PYR, INDICES)
+%
+% Access the highpass residual band from a steerable pyramid.
+
+% Eero Simoncelli, 6/96.
+
+function res =  spyrHigh(pyr,pind)
+
+res  = pyrBand(pyr, pind, 1);
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrHt.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrHt.m
new file mode 100755
index 0000000..8706b9e
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrHt.m
@@ -0,0 +1,16 @@
+% [HEIGHT] = spyrHt(INDICES)
+%
+% Compute height of steerable pyramid with given index matrix.
+
+% Eero Simoncelli, 6/96.
+
+function [ht] =  spyrHt(pind)
+
+nbands = spyrNumBands(pind);
+
+% Don't count lowpass, or highpass residual bands
+if (size(pind,1) > 2)
+  ht = (size(pind,1)-2)/nbands;
+else
+  ht = 0;
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrLev.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrLev.m
new file mode 100755
index 0000000..5cb4a85
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrLev.m
@@ -0,0 +1,24 @@
+% [LEV,IND] = spyrLev(PYR,INDICES,LEVEL)
+%
+% Access a level from a steerable pyramid.
+% Return as an SxB matrix, B = number of bands, S = total size of a band.
+% Also returns an Bx2 matrix containing dimensions of the subbands.
+
+% Eero Simoncelli, 6/96.
+
+function [lev,ind] =  spyrLev(pyr,pind,level)
+
+nbands = spyrNumBands(pind);
+                
+if ((level > spyrHt(pind)) | (level < 1))
+  error(sprintf('Level number must be in the range [1, %d].', spyrHt(pind)));
+end     
+        
+firstband = 2 + nbands*(level-1);
+firstind = 1;
+for l=1:firstband-1
+  firstind = firstind + prod(pind(l,:));
+end
+
+ind = pind(firstband:firstband+nbands-1,:);
+lev  = pyr(firstind:firstind+sum(prod(ind'))-1);
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrNumBands.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrNumBands.m
new file mode 100755
index 0000000..68aec3f
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/spyrNumBands.m
@@ -0,0 +1,20 @@
+% [NBANDS] = spyrNumBands(INDICES)
+%
+% Compute number of orientation bands in a steerable pyramid with
+% given index matrix.  If the pyramid contains only the highpass and
+% lowpass bands (i.e., zero levels), returns 0.
+
+% Eero Simoncelli, 2/97.
+
+function [nbands] =  spyrNumBands(pind)
+
+if (size(pind,1) == 2)
+  nbands  = 0;
+else
+  % Count number of orientation bands:
+  b = 3;
+  while ((b <= size(pind,1)) & all( pind(b,:) == pind(2,:)) )
+    b = b+1;
+  end
+  nbands = b-2;
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/steer.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/steer.m
new file mode 100755
index 0000000..8f9c2ac
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/steer.m
@@ -0,0 +1,68 @@
+% RES = STEER(BASIS, ANGLE, HARMONICS, STEERMTX)
+%
+% Steer BASIS to the specfied ANGLE.  
+% 
+% BASIS should be a matrix whose columns are vectorized rotated copies of a 
+% steerable function, or the responses of a set of steerable filters.
+% 
+% ANGLE can be a scalar, or a column vector the size of the basis.
+% 
+% HARMONICS (optional, default is N even or odd low frequencies, as for 
+% derivative filters) should be a list of harmonic numbers indicating
+% the angular harmonic content of the basis.
+% 
+% STEERMTX (optional, default assumes cosine phase harmonic components,
+% and filter positions at 2pi*n/N) should be a matrix which maps
+% the filters onto Fourier series components (ordered [cos0 cos1 sin1 
+% cos2 sin2 ... sinN]).  See steer2HarmMtx.m
+
+% Eero Simoncelli, 7/96.
+
+function res = steer(basis,angle,harmonics,steermtx)
+
+num = size(basis,2);
+
+if ( any(size(angle) ~= [size(basis,1) 1]) & any(size(angle) ~= [1 1]) )
+  error('ANGLE must be a scalar, or a column vector the size of the basis elements');
+end
+
+%% If HARMONICS are not passed, assume derivatives.
+if (exist('harmonics') ~= 1)
+  if (mod(num,2) == 0)
+    harmonics = [0:(num/2)-1]'*2 + 1;
+  else
+    harmonics = [0:(num-1)/2]'*2;
+  end
+else
+  harmonics = harmonics(:);
+  if ((2*size(harmonics,1)-any(harmonics == 0)) ~= num)
+    error('harmonics list is incompatible with basis size');
+  end
+end
+
+%% If STEERMTX not passed, assume evenly distributed cosine-phase filters:
+if (exist('steermtx') ~= 1)
+  steermtx = steer2HarmMtx(harmonics, pi*[0:num-1]/num, 'even');
+end
+
+steervect = zeros(size(angle,1),num);
+arg = angle * harmonics(find(harmonics~=0))';
+if (all(harmonics))
+        steervect(:, 1:2:num) = cos(arg);
+        steervect(:, 2:2:num) = sin(arg);
+else
+        steervect(:, 1) = ones(size(arg,1),1);
+        steervect(:, 2:2:num) = cos(arg);
+        steervect(:, 3:2:num) = sin(arg);
+end
+
+steervect = steervect * steermtx;
+
+if (size(steervect,1) > 1)
+        tmp = basis' .* steervect';
+        res = sum(tmp)';
+else
+        res = basis * steervect';
+end
+        
+        
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/steer2HarmMtx.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/steer2HarmMtx.m
new file mode 100755
index 0000000..1f3e80e
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/steer2HarmMtx.m
@@ -0,0 +1,71 @@
+% MTX = steer2HarmMtx(HARMONICS, ANGLES, REL_PHASES)
+%
+% Compute a steering matrix (maps a directional basis set onto the
+% angular Fourier harmonics).  HARMONICS is a vector specifying the
+% angular harmonics contained in the steerable basis/filters.  ANGLES 
+% (optional) is a vector specifying the angular position of each filter.  
+% REL_PHASES (optional, default = 'even') specifies whether the harmonics 
+% are cosine or sine phase aligned about those positions.
+% The result matrix is suitable for passing to the function STEER.
+
+% Eero Simoncelli, 7/96.
+
+function mtx = steer2HarmMtx(harmonics, angles, evenorodd)
+
+%%=================================================================
+%%% Optional Parameters:
+
+if (exist('evenorodd') ~= 1)
+  evenorodd = 'even';
+end
+
+% Make HARMONICS a row vector
+harmonics = harmonics(:)';
+
+numh = 2*size(harmonics,2) - any(harmonics == 0);
+
+if (exist('angles') ~= 1)
+  angles = pi * [0:numh-1]'/numh;
+else
+  angles = angles(:);
+end
+
+%%=================================================================
+
+if isstr(evenorodd)
+  if strcmp(evenorodd,'even')
+    evenorodd = 0;
+  elseif strcmp(evenorodd,'odd')
+    evenorodd = 1;
+  else
+    error('EVEN_OR_ODD should be the string  EVEN or ODD');
+  end
+end
+
+%% Compute inverse matrix, which maps Fourier components onto 
+%% steerable basis.
+imtx = zeros(size(angles,1),numh);
+col = 1;
+for h=harmonics
+  args = h*angles;
+  if (h == 0)
+    imtx(:,col) = ones(size(angles));
+    col = col+1;
+  elseif evenorodd
+    imtx(:,col) = sin(args);
+    imtx(:,col+1) = -cos(args);
+    col = col+2;
+  else
+    imtx(:,col) = cos(args);
+    imtx(:,col+1) = sin(args);
+    col = col+2;
+  end
+end
+  
+r = rank(imtx);
+if (( r ~= numh ) & ( r ~= size(angles,1) ))
+  fprintf(2,'WARNING: matrix is not full rank');
+end  
+
+mtx = pinv(imtx);
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/subMtx.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/subMtx.m
new file mode 100755
index 0000000..ea3c2ea
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/subMtx.m
@@ -0,0 +1,21 @@
+% MTX = subMtx(VEC, DIMENSIONS, START_INDEX)
+%
+% Reshape a portion of VEC starting from START_INDEX (optional,
+% default=1) to the given dimensions.
+
+% Eero Simoncelli, 6/96.
+
+function mtx = subMtx(vec, sz, offset)
+
+if (exist('offset') ~= 1)
+   offset = 1;
+end
+
+vec = vec(:);
+sz = sz(:);
+
+if (size(sz,1) ~= 2)
+  error('DIMENSIONS must be a 2-vector.');
+end
+
+mtx = reshape( vec(offset:offset+prod(sz)-1), sz(1), sz(2) );
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/textureAnalysis.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/textureAnalysis.m
new file mode 100755
index 0000000..d7a0ec1
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/textureAnalysis.m
@@ -0,0 +1,245 @@
+function [params] = textureAnalysis(im0, Nsc, Nor, Na)
+
+% Analyze texture for application of Portilla-Simoncelli model/algorithm.
+%
+% [params] = textureAnalysis(im0, Nsc, Nor, Na);
+%       im0:    original image
+%       Nsc:    number of scales
+%       Nor:    number of orientations
+%       Na:     spatial neighborhood considered (Na x Na)       
+%
+% Example: Nsc=4; Nor=4; Na=7;
+%
+% See also textureSynthesis.
+
+% Javier Portilla and Eero Simoncelli.
+% Work described in:
+%  "A Parametric Texture Model based on Joint Statistics of Complex Wavelet Coefficients".
+%  J Portilla and E P Simoncelli. Int'l Journal of Computer Vision,
+%  vol.40(1), pp. 49-71, Dec 2000.   
+%
+% Please refer to this publication if you use the program for research or
+% for technical applications. Thank you.
+%
+% Copyright, Center for Neural Science, New York University, January 2001.
+% All rights reserved.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+Warn = 0;  % Set to 1 if you want to see warning messages
+
+%% Check required args are passed
+if (nargin < 4)
+  error('Function called with too few input arguments');
+end
+
+%% 1D interpolation filter, for scale cross-correlations:
+interp = [-1/16 0 9/16 1 9/16 0 -1/16]/sqrt(2);
+
+if ( mod(Na,2) == 0 )
+  error('Na is not an odd integer');
+end
+
+%% If the spatial neighborhood Na is too big for the lower scales,
+%% "modacor22.m" will make it as big as the spatial support at
+%% each scale:
+
+[Ny,Nx] = size(im0);
+nth = log2(min(Ny,Nx)/Na);
+if nth<Nsc & Warn,
+  fprintf(1,'Warning: Na will be cut off for levels above #%d !\n', floor(nth+1));
+end
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+la = floor((Na-1)/2);
+
+%% Pixel statistics
+[mn0 mx0] = size(im0);
+mean0 = mean2(im0);
+var0 = var2(im0, mean0);
+skew0 = skew2(im0, mean0, var0);
+kurt0 = kurt2(im0, mean0, var0);
+statg0 = [mean0 var0 skew0 kurt0 mn0 mx0];
+
+% Add a little bit of noise to the original, in case it has been 
+% artificially generated, to avoid instability crated by symmetric
+% conditions at the synthesis stage.
+
+%im0 = im0 + (mx0-mn0)/1000*randn(size(im0));        %kvs
+
+%% Build the steerable pyramid
+[pyr0,pind0] = buildSCFpyr(im0,Nsc,Nor-1);
+
+if ( any(vector(mod(pind0,2))) )
+  error('Algorithm will fail: Some bands have odd dimensions!');
+end
+
+%% Subtract mean of lowBand:
+nband = size(pind0,1);
+pyr0(pyrBandIndices(pind0,nband)) = ...
+    real(pyrBand(pyr0,pind0,nband)) - mean2(real(pyrBand(pyr0,pind0,nband)));
+
+rpyr0 = real(pyr0);
+apyr0 = abs(pyr0);
+
+figure(gcf)
+clf
+showIm(im0,'auto',1); title('Original');  drawnow
+
+%% Subtract mean of magnitude:
+magMeans0 = zeros(size(pind0,1), 1);
+for nband = 1:size(pind0,1)
+  indices = pyrBandIndices(pind0,nband);
+  magMeans0(nband) = mean2(apyr0(indices));
+  apyr0(indices) = apyr0(indices) - magMeans0(nband);
+end
+
+%% Compute central autoCorr of lowband
+acr = NaN * ones(Na,Na,Nsc+1);
+nband = size(pind0,1);
+ch = pyrBand(pyr0,pind0,nband);
+[mpyr,mpind] = buildSFpyr(real(ch),0,0);
+im = pyrBand(mpyr,mpind,2);
+[Nly Nlx] = size(ch);
+Sch = min(Nly,Nlx); %size of low band
+le = min(Sch/2-1,la);
+cy = Nly/2+1;
+cx = Nlx/2+1;
+ac = fftshift(real(ifft2(abs(fft2(im)).^2)))/prod(size(ch));
+ac = ac(cy-le:cy+le,cx-le:cx+le);
+acr(la-le+1:la+le+1,la-le+1:la+le+1,Nsc+1) = ac;
+skew0p = zeros(Nsc+1,1);
+kurt0p = zeros(Nsc+1,1);
+vari = ac(le+1,le+1);
+if vari/var0 > 1e-6,
+        skew0p(Nsc+1) = mean2(im.^3)/vari^1.5;
+        kurt0p(Nsc+1) = mean2(im.^4)/vari^2;
+else
+        skew0p(Nsc+1) = 0;
+        kurt0p(Nsc+1) = 3;
+end
+
+%% Compute  central autoCorr of each Mag band, and the autoCorr of the
+%% combined (non-oriented) band.
+ace = NaN * ones(Na,Na,Nsc,Nor);
+for nsc = Nsc:-1:1,
+  for nor = 1:Nor,
+    nband = (nsc-1)*Nor+nor+1;
+    ch = pyrBand(apyr0,pind0,nband);
+    [Nly, Nlx] = size(ch);
+    Sch = min(Nlx, Nly);
+    le = min(Sch/2-1,la);
+    cx = Nlx/2+1;  %Assumes Nlx even
+    cy = Nly/2+1;
+    ac = fftshift(real(ifft2(abs(fft2(ch)).^2)))/prod(size(ch));
+    ac = ac(cy-le:cy+le,cx-le:cx+le);
+    ace(la-le+1:la+le+1,la-le+1:la+le+1,nsc,nor) = ac;
+  end
+
+  %% Combine ori bands
+
+  bandNums = [1:Nor] + (nsc-1)*Nor+1;  %ori bands only
+  ind1 = pyrBandIndices(pind0, bandNums(1));
+  indN = pyrBandIndices(pind0, bandNums(Nor));
+  bandInds = [ind1(1):indN(length(indN))];
+  %% Make fake pyramid, containing dummy hi, ori, lo
+  fakePind = [pind0(bandNums(1),:);pind0(bandNums(1):bandNums(Nor)+1,:)];
+  fakePyr = [zeros(prod(fakePind(1,:)),1);...
+         rpyr0(bandInds); zeros(prod(fakePind(size(fakePind,1),:)),1);];
+  ch = reconSFpyr(fakePyr, fakePind, [1]);     % recon ori bands only
+  im = real(expand(im,2))/4;
+  im = im + ch;  
+  ac = fftshift(real(ifft2(abs(fft2(im)).^2)))/prod(size(ch));
+  ac = ac(cy-le:cy+le,cx-le:cx+le);
+  acr(la-le+1:la+le+1,la-le+1:la+le+1,nsc) = ac;
+  vari = ac(le+1,le+1);
+  if vari/var0 > 1e-6,
+        skew0p(nsc) = mean2(im.^3)/vari^1.5;
+        kurt0p(nsc) = mean2(im.^4)/vari^2;
+  else
+        skew0p(nsc) = 0;
+        kurt0p(nsc) = 3;
+  end
+end
+
+%% Compute the cross-correlation matrices of the coefficient magnitudes
+%% pyramid at the different levels and orientations
+
+C0 = zeros(Nor,Nor,Nsc+1);
+Cx0 = zeros(Nor,Nor,Nsc);
+
+Cr0 = zeros(2*Nor,2*Nor,Nsc+1);
+Crx0 = zeros(2*Nor,2*Nor,Nsc);
+
+for nsc = 1:Nsc,
+  firstBnum = (nsc-1)*Nor+2;
+  cousinSz = prod(pind0(firstBnum,:));
+  ind = pyrBandIndices(pind0,firstBnum);
+  cousinInd = ind(1) + [0:Nor*cousinSz-1];
+
+  if (nsc<Nsc)
+    parents = zeros(cousinSz,Nor);
+    rparents = zeros(cousinSz,Nor*2);
+    for nor=1:Nor,
+      nband = (nsc-1+1)*Nor+nor+1;
+
+      tmp = expand(pyrBand(pyr0, pind0, nband),2)/4;
+      rtmp = real(tmp); itmp = imag(tmp);
+      %% Double phase:
+      tmp = sqrt(rtmp.^2 + itmp.^2) .* exp(2 * sqrt(-1) * atan2(rtmp,itmp));
+      rparents(:,nor) = vector(real(tmp));
+      rparents(:,Nor+nor) = vector(imag(tmp));
+
+      tmp = abs(tmp);
+      parents(:,nor) = vector(tmp - mean2(tmp));
+    end
+  else
+    tmp = real(expand(pyrLow(rpyr0,pind0),2))/4;
+    rparents = [vector(tmp),...
+                vector(shift(tmp,[0 1])), vector(shift(tmp,[0 -1])), ...
+                vector(shift(tmp,[1 0])), vector(shift(tmp,[-1 0]))];
+    parents = [];
+  end
+
+  cousins = reshape(apyr0(cousinInd), [cousinSz Nor]);
+  nc = size(cousins,2);   np = size(parents,2);
+  C0(1:nc,1:nc,nsc) = innerProd(cousins)/cousinSz;
+  if (np > 0)
+    Cx0(1:nc,1:np,nsc) = (cousins'*parents)/cousinSz;
+    if (nsc==Nsc)
+      C0(1:np,1:np,Nsc+1) = innerProd(parents)/(cousinSz/4);
+    end
+  end
+  
+  cousins = reshape(real(pyr0(cousinInd)), [cousinSz Nor]);
+  nrc = size(cousins,2);   nrp = size(rparents,2);  
+  Cr0(1:nrc,1:nrc,nsc) = innerProd(cousins)/cousinSz;
+  if (nrp > 0)
+    Crx0(1:nrc,1:nrp,nsc) = (cousins'*rparents)/cousinSz;
+    if (nsc==Nsc)
+      Cr0(1:nrp,1:nrp,Nsc+1) = innerProd(rparents)/(cousinSz/4);
+    end
+  end
+end
+
+%% Calculate the mean, range and variance of the LF and HF residuals' energy.
+
+channel = pyr0(pyrBandIndices(pind0,1));
+vHPR0 = mean2(channel.^2);
+
+statsLPim = [skew0p kurt0p];
+
+params = struct('pixelStats', statg0, ...
+                'pixelLPStats', statsLPim, ...
+                'autoCorrReal', acr, ...
+                'autoCorrMag', ace, ...
+                'magMeans', magMeans0, ...
+                'cousinMagCorr', C0, ...
+                'parentMagCorr', Cx0, ...
+                'cousinRealCorr', Cr0, ...
+                'parentRealCorr', Crx0, ...
+                'varianceHPR', vHPR0);
+
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/textureSynthesis.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/textureSynthesis.m
new file mode 100755
index 0000000..38fce5a
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/textureSynthesis.m
@@ -0,0 +1,436 @@
+function [im,snrP,imS] = textureSynthesis(params, im0, Niter, cmask, imask)
+
+% [res,snrP,imS] = textureSynthesis(params, initialIm, Niter, cmask, imask)
+%
+% Synthesize texture applying Portilla-Simoncelli model/algorithm.
+%       
+% params: structure containing texture parameters (as returned by textureAnalysis).
+%
+% im0: initial image, OR a vector (Ydim, Xdim, [SEED]) containing
+% dimensions of desired image and an optional seed for the random
+% number generator.  If dimensions are passed, initial image is
+% Gaussian white noise.
+%
+% Niter (optional): Number of iterations.  Default = 50.
+%
+% cmask (optional): binary column vector (4x1) indicating which sets of
+% constraints we want to apply in the synthesis. The four sets are:
+%               1) Marginal statistics (mean, var, skew, kurt, range)
+%               2) Correlation of subbands (space, orientation, scale)
+%               3) Correlation of magnitude responses (sp, or, sc)
+%               4) Relative local phase
+%
+% imask (optional): imsizex2 matrix.  First column is a mask, second
+%       column contains the image values to be imposed. If only one column is
+%       provided, it assumes it corresponds to the image values, and it uses
+%       a raised cosine square for the mask.
+% snrP (optional):      Set of adjustment values (in dB) of the parameters.
+% imS (optional):       Sequence of synthetic images, from niter = 1 to 2^n, being
+%                       n = floor(log2(Niter)).
+
+% Javier Portilla and Eero Simoncelli.
+% Work described in:
+%  "A Parametric Texture Model based on Joint Statistics of Complex Wavelet Coefficients".
+%  J Portilla and E P Simoncelli. Int'l Journal of Computer Vision,
+%  vol.40(1), pp. 49-71, Dec 2000.   
+%
+% Please refer to this publication if you use the program for research or
+% for technical applications. Thank you.
+%
+% Copyright, Center for Neural Science, New York University, January 2001.
+% All rights reserved.
+
+Warn = 0;  % Set to 1 if you want to see warning messages
+
+%% Check required args are passed:
+if (nargin < 2)
+  error('Function called with too few input arguments');
+end
+
+if ( ~exist('Niter') | isempty(Niter) )
+  Niter = 50;
+end
+
+if (exist('cmask') & ~isempty(cmask) )
+  cmask = (cmask > 0.5);  % indices of ones in mask
+else
+  cmask = ones(4,1);
+end
+
+%% Extract parameters  
+statg0 = params.pixelStats;
+mean0 = statg0(1); var0 =  statg0(2);
+skew0 =  statg0(3); kurt0 =  statg0(4);
+mn0 =  statg0(5);  mx0 = statg0(6);
+statsLPim = params.pixelLPStats;
+skew0p = statsLPim(:,1);
+kurt0p = statsLPim(:,2);
+vHPR0 = params.varianceHPR;
+acr0 = params.autoCorrReal;
+ace0 = params.autoCorrMag;
+magMeans0 = params.magMeans;
+C0 = params.cousinMagCorr;
+Cx0 = params.parentMagCorr;
+Crx0 = params.parentRealCorr;
+
+%% Extract {Nsc, Nor, Na} from params
+tmp = size(params.autoCorrMag);
+Na = tmp(1); Nsc = tmp(3);
+Nor = tmp(length(tmp))*(length(tmp)==4) + (length(tmp)<4);
+la = (Na-1)/2;
+
+%% If im0 is a vector of length 2, create Gaussian white noise image of this
+%% size, with desired pixel mean and variance.  If vector length is
+%% 3,  use the 3rd element to seed the random number generator.
+if ( length(im0) <= 3 )
+  if ( length(im0) == 3)
+    randn('state', im0(3)); % Reset Seed
+    im0 = im0(1:2);
+  end
+  im = mean0 + sqrt(var0)*randn(im0);
+else
+  im = im0;
+end
+
+%% If the spatial neighborhood Na is too big for the lower scales,
+%% "modacor22.m" will make it as big as the spatial support at
+%% each scale:
+[Ny,Nx] = size(im);
+nth = log2(min(Ny,Nx)/Na);
+if nth<Nsc+1 & Warn,
+  fprintf(1,'Warning: Na will be cut off for levels above #%d !\n',floor(nth));
+end
+
+if  exist('imask') & ~isempty(imask),
+        if  size(imask,1) ~= prod(size(im))
+                error(sprintf('imask size %d does not match image dimensions [%d,%d]',...
+                size(imask,1), size(im,1), size(im,2)));
+        end
+        if size(imask,2) == 1,
+                mask = (cos(-pi/2:2*pi/Ny:pi*(1-2/Ny)/2)).'*cos(-pi/2:2*pi/Nx:pi*(1-2/Nx)/2);
+                mask = mask.^2;
+                aux = zeros(size(im));
+                aux(Ny/4+1:Ny/4+Ny/2,Nx/4+1:Nx/4+Nx/2)=mask;
+                mask = aux;
+        else
+                mask = reshape(imask(:,1),size(im));
+        end
+end
+
+imf = max(1,gcf-1); snrf = imf+1;
+figure(imf);  clf
+subplot(1,2,1); grayRange = showIm(im,'auto',1); title('Starting image');
+drawnow
+
+prev_im=im;
+
+imf = max(1,gcf-1);
+figure(imf);   
+clf;showIm(im,'auto',1); title(sprintf('iteration 0'));
+
+nq = 0;
+Nq = floor(log2(Niter));
+imS = zeros(Ny,Nx,Nq);
+
+%% MAIN LOOP
+for niter = 1:Niter
+
+%p = niter/Niter; 
+p = 1;
+
+  %% Build the steerable pyramid
+  [pyr,pind] = buildSCFpyr(im,Nsc,Nor-1);
+
+  if ( any(vector(mod(pind,4))) )
+    error('Algorithm will fail: band dimensions are not all multiples of 4!');
+  end
+
+  %% Subtract mean of lowBand:
+  nband = size(pind,1);
+  pyr(pyrBandIndices(pind,nband)) = ...
+      pyrBand(pyr,pind,nband) - mean2(pyrBand(pyr,pind,nband));
+
+  apyr = abs(pyr);
+
+  %% Adjust autoCorr of lowBand
+  nband = size(pind,1); 
+  ch = pyrBand(pyr,pind,nband);
+  Sch = min(size(ch)/2);
+  nz = sum(sum(~isnan(acr0(:,:,Nsc+1))));
+  lz = (sqrt(nz)-1)/2;
+  le = min(Sch/2-1,lz);
+  im = real(ch);  %Reconstructed image: initialize to lowband
+  [mpyr,mpind] = buildSFpyr(im,0,0);
+  im = pyrBand(mpyr,mpind,2);
+  vari =  acr0(la+1:la+1,la+1:la+1,Nsc+1);
+if cmask(2),
+  if vari/var0 > 1e-4,
+        [im, snr2(niter,Nsc+1)] = ...
+        modacor22(im, acr0(la-le+1:la+le+1,la-le+1:la+le+1,Nsc+1),p);
+  else
+        im = im*sqrt(vari/var2(im));
+  end
+  if (var2(imag(ch))/var2(real(ch)) > 1e-6)
+    fprintf(1,'Discarding non-trivial imaginary part, lowPass autoCorr!');
+  end
+  im = real(im);
+end % cmask(2)
+if cmask(1),
+  if vari/var0 > 1e-4,
+        [im,snr7(niter,2*(Nsc+1)-1)] = modskew(im,skew0p(Nsc+1),p);     % Adjusts skewness 
+        [im,snr7(niter,2*(Nsc+1))] = modkurt(im,kurt0p(Nsc+1),p);       % Adjusts kurtosis 
+  end
+end     % cmask(2)
+ 
+  %% Subtract mean of magnitude
+if cmask(3),
+  magMeans = zeros(size(pind,1), 1);
+  for nband = 1:size(pind,1)
+    indices = pyrBandIndices(pind,nband);
+    magMeans(nband) = mean2(apyr(indices));
+    apyr(indices) = apyr(indices) - magMeans(nband);
+  end
+end     % cmask(3)
+
+  %% Coarse-to-fine loop:
+  for nsc = Nsc:-1:1
+    
+    firstBnum = (nsc-1)*Nor+2;
+    cousinSz = prod(pind(firstBnum,:));
+    ind = pyrBandIndices(pind,firstBnum);
+    cousinInd = ind(1) + [0:Nor*cousinSz-1];
+
+    %% Interpolate parents
+if (cmask(3) | cmask(4)),
+    if (nsc<Nsc)
+      parents = zeros(cousinSz,Nor);
+      rparents = zeros(cousinSz,Nor*2);
+      for nor = 1:Nor
+        nband = (nsc+1-1)*Nor+nor+1; 
+
+        tmp = expand(pyrBand(pyr, pind, nband),2)/4;
+        rtmp = real(tmp); itmp = imag(tmp);
+        tmp = sqrt(rtmp.^2 + itmp.^2) .* exp(2 * sqrt(-1) * atan2(rtmp,itmp));
+        rparents(:,nor) = vector(real(tmp));
+        rparents(:,Nor+nor) = vector(imag(tmp));
+
+        tmp = abs(tmp);
+        parents(:,nor) = vector(tmp - mean2(tmp));
+      end
+    else
+      rparents = [];
+      parents = [];
+    end
+end % if (cmask(3) | cmask(4))
+
+if cmask(3),
+    %% Adjust cross-correlation with MAGNITUDES at other orientations/scales:
+    cousins = reshape(apyr(cousinInd), [cousinSz Nor]);
+    nc = size(cousins,2);   np = size(parents,2);
+    if (np == 0)    
+      [cousins, snr3(niter,nsc)] = adjustCorr1s(cousins, C0(1:nc,1:nc,nsc), 2, p);
+    else
+      [cousins, snr3(niter,nsc), snr4(niter,nsc)] = ...
+          adjustCorr2s(cousins, C0(1:nc,1:nc,nsc), parents, Cx0(1:nc,1:np,nsc), 3, p);
+    end
+    if (var2(imag(cousins))/var2(real(cousins)) > 1e-6)
+      fprintf(1,'Non-trivial imaginary part, mag crossCorr, lev=%d!\n',nsc);
+    else
+      cousins = real(cousins);
+      ind = cousinInd;
+      apyr(ind) = vector(cousins);
+    end
+
+    %% Adjust autoCorr of mag responses 
+    nband = (nsc-1)*Nor+2; 
+    Sch = min(pind(nband,:)/2);
+    nz = sum(sum(~isnan(ace0(:,:,nsc,1))));
+    lz = (sqrt(nz)-1)/2;
+    le = min(Sch/2-1,lz);
+    for nor = 1:Nor,
+      nband = (nsc-1)*Nor+nor+1; 
+      ch = pyrBand(apyr,pind,nband);
+      [ch, snr1(niter,nband-1)] = modacor22(ch,...
+        ace0(la-le+1:la+le+1,la-le+1:la+le+1,nsc,nor), p);
+      ch = real(ch);
+      ind = pyrBandIndices(pind,nband);
+      apyr(ind) = ch;
+      %% Impose magnitude:
+      mag = apyr(ind) + magMeans0(nband);
+      mag = mag .* (mag>0);
+      pyr(ind) = pyr(ind) .* (mag./(abs(pyr(ind))+(abs(pyr(ind))<eps)));
+    end
+end   % cmask(3)
+
+    %% Adjust cross-correlation of REAL PARTS at other orientations/scales:
+    cousins = reshape(real(pyr(cousinInd)), [cousinSz Nor]);
+    Nrc = size(cousins,2);  Nrp = size(rparents,2);
+    if  cmask(4) & (Nrp ~= 0)
+        a3 = 0; a4 = 0;
+        for nrc = 1:Nrc,
+          cou = cousins(:,nrc);
+          [cou, s3, s4] = ...
+            adjustCorr2s(cou,mean(cou.^2),rparents,Crx0(nrc,1:Nrp,nsc), 3);
+          a3 = s3 + a3;
+          a4 = s4 + a4;
+          cousins(:,nrc) = cou;
+        end
+        snr4r(niter,nsc) = a4/Nrc;
+    end
+    if (var2(imag(cousins))/var2(real(cousins)) > 1e-6)
+      fprintf(1,'Non-trivial imaginary part, real crossCorr, lev=%d!\n',nsc);
+    else
+      %%% NOTE: THIS SETS REAL PART ONLY - signal is now NONANALYTIC!
+      pyr(cousinInd) = vector(cousins(1:Nor*cousinSz));
+    end
+
+    %% Re-create analytic subbands
+    dims = pind(firstBnum,:);
+    ctr = ceil((dims+0.5)/2);
+    ang = mkAngle(dims, 0, ctr);
+    ang(ctr(1),ctr(2)) = -pi/2;
+    for nor = 1:Nor,
+      nband = (nsc-1)*Nor+nor+1; 
+      ind = pyrBandIndices(pind,nband); 
+      ch = pyrBand(pyr, pind, nband);
+      ang0 = pi*(nor-1)/Nor;
+      xang = mod(ang-ang0+pi, 2*pi) - pi;
+      amask = 2*(abs(xang) < pi/2) + (abs(xang) == pi/2);
+      amask(ctr(1),ctr(2)) = 1;
+      amask(:,1) = 1;
+      amask(1,:) = 1; 
+      amask = fftshift(amask);
+      ch = ifft2(amask.*fft2(ch));      % "Analytic" version
+      pyr(ind) = ch;
+    end
+
+    %% Combine ori bands
+    bandNums = [1:Nor] + (nsc-1)*Nor+1;  %ori bands only
+    ind1 = pyrBandIndices(pind, bandNums(1));
+    indN = pyrBandIndices(pind, bandNums(Nor));
+    bandInds = [ind1(1):indN(length(indN))];
+    %% Make fake pyramid, containing dummy hi, ori, lo
+    fakePind = pind([bandNums(1), bandNums, bandNums(Nor)+1],:);
+    fakePyr = [zeros(prod(fakePind(1,:)),1);...
+         real(pyr(bandInds)); zeros(prod(fakePind(size(fakePind,1),:)),1)]; 
+    ch = reconSFpyr(fakePyr, fakePind, [1]);     % recon ori bands only
+    im = real(expand(im,2))/4;
+    im = im + ch;
+    vari =  acr0(la+1:la+1,la+1:la+1,nsc);
+if cmask(2),
+    if vari/var0 > 1e-4,
+        [im, snr2(niter,nsc)] = ...
+        modacor22(im, acr0(la-le+1:la+le+1,la-le+1:la+le+1,nsc), p);
+    else
+        im = im*sqrt(vari/var2(im));
+    end
+end     % cmask(2)
+    im = real(im);  
+
+if cmask(1),
+  %% Fix marginal stats 
+  if vari/var0 > 1e-4,
+        [im,snr7(niter,2*nsc-1)] = modskew(im,skew0p(nsc),p);       % Adjusts skewness 
+        [im,snr7(niter,2*nsc)] = modkurt(im,kurt0p(nsc),p);         % Adjusts kurtosis
+  end
+end     % cmask(1)
+
+  end  %END Coarse-to-fine loop
+
+  %% Adjust variance in HP, if higher than desired
+if (cmask(2)|cmask(3)|cmask(4)),
+  ind = pyrBandIndices(pind,1);
+  ch = pyr(ind);
+  vHPR = mean2(ch.^2);
+  if vHPR > vHPR0,
+        ch = ch * sqrt(vHPR0/vHPR);
+        pyr(ind) = ch;
+  end
+end % cmask
+  im = im + reconSFpyr(real(pyr), pind, [0]);  %recon hi only
+
+  %% Pixel statistics
+  means = mean2(im);
+  vars = var2(im, means);
+  snr7(niter,2*(Nsc+1)+1) = snr(var0,var0-vars);
+  im = im-means;                        % Adjusts mean and variance
+  [mns mxs] = range2(im + mean0);
+  snr7(niter,2*(Nsc+1)+2) = snr(mx0-mn0,sqrt((mx0-mxs)^2+(mn0-mns)^2));
+if cmask(1),
+  im = im*sqrt(((1-p)*vars + p*var0)/vars);     
+end     % cmaks(1)
+  im = im+mean0;
+if cmask(1),
+  [im, snr7(niter,2*(Nsc+1)+3)] = modskew(im,skew0,p);  % Adjusts skewness (keep mean and variance)
+  [im, snr7(niter,2*(Nsc+1)+4)] = modkurt(im,kurt0,p);  % Adjusts kurtosis (keep mean and variance,
+                                        % but not skewness)
+  im = max(min(im,(1-p)*max(max(im))+p*mx0),...
+                  (1-p)*min(min(im))+p*mn0);            % Adjusts range (affects everything)    
+else 
+  snr7(niter,2*(Nsc+1)+3) = snr(skew0,skew0-skew2(im));
+  snr7(niter,2*(Nsc+1)+4) = snr(kurt0,kurt0-kurt2(im));
+end     % cmask(1)
+
+  %% Force pixels specified by image mask
+  if (exist('imask') & ~isempty(imask) )
+        im = mask.*reshape(imask(:,2 - (size(imask,2)==1)),size(im)) + ...
+                (1-mask).*im;
+  end
+
+  snr6(niter,1) = snr(im-mean0,im-prev_im);
+
+  if floor(log2(niter))==log2(niter),
+        nq = nq + 1;
+        imS(:,:,nq) = im;
+  end
+
+  tmp = prev_im;
+  prev_im=im;   
+
+  figure(imf);
+  subplot(1,2,1);
+  showIm(im-tmp,'auto',1); title('Change');
+  subplot(1,2,2);
+  showIm(im,'auto',1); title(sprintf('iteration %d/%d',niter,Niter));
+  drawnow
+  
+  % accelerator
+  alpha = 0.8;
+  im = im + alpha*(im - tmp);
+  
+commented = 1;  % set it to 0 for displaying convergence of parameters in SNR (dB)
+if ~commented,    
+   
+% The graphs that appear reflect
+% the relative distance of each parameter or group
+% of parametersi, to the original's, in decibels.
+% Note, however, that when the original parameters
+% are close to zero, this measurement is meaningless.
+% This is why in some cases it seems that some of
+% the parameters do not converge at all.
+
+figure(snrf);
+if cmask(1)
+  subplot(171); plot(snr7); title('Mrgl stats');
+end
+if cmask(2),
+  subplot(172); plot(snr2); title('Raw auto');
+end
+if cmask(3),
+  subplot(173); plot(snr1); title('Mag auto'); 
+  subplot(174); plot(snr3); title('Mag ori');
+  subplot(175); plot(snr4); title('Mag scale');
+end
+if (Nrp > 0) & cmask(4),
+  subplot(176); plot(snr4r); title('Phs scale');
+end
+  subplot(177); plot(snr6); title('Im change');
+  drawnow
+  
+end  % if ~commented
+
+end %END  MAIN LOOP
+
+im = prev_im;
+
+snrP = [snr7 snr2 snr1 snr3 snr4 snr4r snr6];
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/upBlur.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/upBlur.m
new file mode 100755
index 0000000..948c2e1
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/upBlur.m
@@ -0,0 +1,52 @@
+% RES = upBlur(IM, LEVELS, FILT)
+%
+% Upsample and blur an image.  The blurring is done with filter
+% kernel specified by FILT (default = 'binom5'), which can be a string
+% (to be passed to namedFilter), a vector (applied separably as a 1D
+% convolution kernel in X and Y), or a matrix (applied as a 2D
+% convolution kernel).  The downsampling is always by 2 in each
+% direction.
+%
+% The procedure is applied recursively LEVELS times (default=1).
+
+% Eero Simoncelli, 4/97.
+
+function res = upBlur(im, nlevs, filt)
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('nlevs') ~= 1) 
+  nlevs = 1;
+end
+
+if (exist('filt') ~= 1) 
+  filt = 'binom5';
+end
+
+%------------------------------------------------------------
+
+if isstr(filt)
+  filt = namedFilter(filt);
+end  
+
+if nlevs > 1
+  im = upBlur(im,nlevs-1,filt);
+end
+
+if (nlevs >= 1)
+  if (any(size(im)==1))
+    if (size(im,1)==1)
+      filt = filt';
+    end
+    res = upConv(im,filt,'reflect1',(size(im)~=1)+1);
+  elseif (any(size(filt)==1))
+    filt = filt(:);
+    res = upConv(im,filt,'reflect1',[2 1]);
+    res = upConv(res,filt','reflect1',[1 2]);
+  else
+    res = upConv(im,filt,'reflect1',[2 2]);
+  end
+else
+  res = im;
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/upConv.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/upConv.m
new file mode 100755
index 0000000..10bea46
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/upConv.m
@@ -0,0 +1,80 @@
+% RES = upConv(IM, FILT, EDGES, STEP, START, STOP, RES)
+%
+% Upsample matrix IM, followed by convolution with matrix FILT.  These
+% arguments should be 1D or 2D matrices, and IM must be larger (in
+% both dimensions) than FILT.  The origin of filt
+% is assumed to be floor(size(filt)/2)+1.
+%
+% EDGES is a string determining boundary handling:
+%    'circular' - Circular convolution
+%    'reflect1' - Reflect about the edge pixels
+%    'reflect2' - Reflect, doubling the edge pixels
+%    'repeat'   - Repeat the edge pixels
+%    'zero'     - Assume values of zero outside image boundary
+%    'extend'   - Reflect and invert
+%    'dont-compute' - Zero output when filter overhangs OUTPUT boundaries
+%
+% Upsampling factors are determined by STEP (optional, default=[1 1]),
+% a 2-vector [y,x].
+% 
+% The window over which the convolution occurs is specfied by START 
+% (optional, default=[1,1], and STOP (optional, default = 
+% step .* (size(IM) + floor((start-1)./step))).
+%
+% RES is an optional result matrix.  The convolution result will be 
+% destructively added into this matrix.  If this argument is passed, the 
+% result matrix will not be returned. DO NOT USE THIS ARGUMENT IF 
+% YOU DO NOT UNDERSTAND WHAT THIS MEANS!!
+% 
+% NOTE: this operation corresponds to multiplication of a signal
+% vector by a matrix whose columns contain copies of the time-reversed
+% (or space-reversed) FILT shifted by multiples of STEP.  See corrDn.m
+% for the operation corresponding to the transpose of this matrix.
+
+% Eero Simoncelli, 6/96.  revised 2/97.
+
+function result = upConv(im,filt,edges,step,start,stop,res)
+
+%% THIS CODE IS NOT ACTUALLY USED! (MEX FILE IS CALLED INSTEAD)
+
+%fprintf(1,'WARNING: You should compile the MEX version of "upConv.c",\n         found in the MEX subdirectory of matlabPyrTools, and put it in your matlab path.  It is MUCH faster, and provides more boundary-handling options.\n');
+
+%------------------------------------------------------------
+%% OPTIONAL ARGS:
+
+if (exist('edges') == 1) 
+  if (strcmp(edges,'reflect1') ~= 1)
+    warning('Using REFLECT1 edge-handling (use MEX code for other options).');
+  end
+end
+
+if (exist('step') ~= 1)
+  step = [1,1];
+end     
+
+if (exist('start') ~= 1)
+  start = [1,1];
+end     
+
+% A multiple of step
+if (exist('stop') ~= 1)
+  stop = step .* (floor((start-ones(size(start)))./step)+size(im))
+end     
+
+if ( ceil((stop(1)+1-start(1)) / step(1)) ~= size(im,1) )
+  error('Bad Y result dimension');
+end
+if ( ceil((stop(2)+1-start(2)) / step(2)) ~= size(im,2) )
+  error('Bad X result dimension');
+end
+
+if (exist('res') ~= 1)
+  res = zeros(stop-start+1);
+end     
+
+%------------------------------------------------------------
+
+tmp = zeros(size(res));
+tmp(start(1):step(1):stop(1),start(2):step(2):stop(2)) = im;
+
+result = rconv2(tmp,filt) + res;
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/var2.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/var2.m
new file mode 100755
index 0000000..6957eff
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/var2.m
@@ -0,0 +1,17 @@
+% V = VAR2(MTX,MEAN)
+%
+% Sample variance of a matrix.
+%  Passing MEAN (optional) makes the calculation faster.
+
+function res = var2(mtx, mn)
+
+if (exist('mn') ~= 1)
+  mn =  mean2(mtx);
+end
+
+if (isreal(mtx))
+  res = sum(sum(abs(mtx-mn).^2)) / max((prod(size(mtx)) - 1),1);
+else
+  res = sum(sum(real(mtx-mn).^2)) + i*sum(sum(imag(mtx-mn).^2));
+  res = res  / max((prod(size(mtx)) - 1),1);
+end
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/vectify.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/vectify.m
new file mode 100755
index 0000000..3664223
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/vectify.m
@@ -0,0 +1,8 @@
+% [VEC] = columnize(MTX)
+% 
+% Pack elements of MTX into a column vector.  Just provides a
+% function-call notatoin for the operation MTX(:)
+
+function vec = columnize(mtx)
+
+vec = mtx(:);
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/vector.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/vector.m
new file mode 100755
index 0000000..6168151
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/vector.m
@@ -0,0 +1,7 @@
+% [VEC] = vector(MTX)
+% 
+% Pack elements of MTX into a column vector.  Same as VEC = MTX(:)
+
+function vec = vector(mtx)
+
+vec = mtx(:);
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/wpyrBand.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/wpyrBand.m
new file mode 100755
index 0000000..c027cca
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/wpyrBand.m
@@ -0,0 +1,39 @@
+% RES = wpyrBand(PYR, INDICES, LEVEL, BAND)
+%
+% Access a subband from a separable QMF/wavelet pyramid.  
+% 
+% LEVEL (optional, default=1) indicates the scale (finest = 1,
+% coarsest = wpyrHt(INDICES)).  
+% 
+% BAND (optional, default=1) indicates which subband (1=horizontal,
+% 2=vertical, 3=diagonal).
+
+% Eero Simoncelli, 6/96.
+
+function im =  wpyrBand(pyr,pind,level,band)
+
+if (exist('level') ~= 1)
+  level = 1;
+end
+
+if (exist('band') ~= 1)
+  band = 1;
+end
+
+if ((pind(1,1) == 1) | (pind(1,2) ==1))
+  nbands = 1;
+else
+  nbands = 3;
+end
+                
+if ((band > nbands) | (band < 1))
+  error(sprintf('Bad band number (%d) should be in range [1,%d].', band, nbands));
+end
+        
+maxLev = wpyrHt(pind);
+if ((level > maxLev) | (level < 1))
+  error(sprintf('Bad level number (%d), should be in range [1,%d].', level, maxLev));
+end
+
+band = band + nbands*(level-1);
+im = pyrBand(pyr,pind,band);
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/wpyrHt.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/wpyrHt.m
new file mode 100755
index 0000000..476be83
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/wpyrHt.m
@@ -0,0 +1,15 @@
+% [HEIGHT] = wpyrHt(INDICES)
+%
+% Compute height of separable QMF/wavelet pyramid with given index matrix.
+
+% Eero Simoncelli, 6/96.
+
+function [ht] =  wpyrHt(pind)
+
+if ((pind(1,1) == 1) | (pind(1,2) ==1))
+        nbands = 1;
+else
+        nbands = 3;
+end
+
+ht = (size(pind,1)-1)/nbands;
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/wpyrLev.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/wpyrLev.m
new file mode 100755
index 0000000..18f30ae
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/wpyrLev.m
@@ -0,0 +1,30 @@
+% [LEV,IND] = wpyrLev(PYR,INDICES,LEVEL)
+%
+% Access a level from a separable QMF/wavelet pyramid.
+% Return as an SxB matrix, B = number of bands, S = total size of a band.
+% Also returns an Bx2 matrix containing dimensions of the subbands.
+
+% Eero Simoncelli, 6/96.
+
+function [lev,ind] =  wpyrLev(pyr,pind,level)
+
+if ((pind(1,1) == 1) | (pind(1,2) ==1))
+  nbands = 1;
+else
+  nbands = 3;
+end
+                
+if ((level > wpyrHt(pind)) | (level < 1))
+  error(sprintf('Level number must be in the range [1, %d].', wpyrHt(pind)));
+end     
+        
+firstband = 1 + nbands*(level-1)
+firstind = 1;
+for l=1:firstband-1
+  firstind = firstind + prod(pind(l,:));
+end
+
+
+ind = pind(firstband:firstband+nbands-1,:);
+lev  = pyr(firstind:firstind+sum(prod(ind'))-1);
+
diff --git a/SD-VBS/benchmarks/texture_synthesis/src/matlab/zconv2.m b/SD-VBS/benchmarks/texture_synthesis/src/matlab/zconv2.m
new file mode 100755
index 0000000..f678d89
--- /dev/null
+++ b/SD-VBS/benchmarks/texture_synthesis/src/matlab/zconv2.m
@@ -0,0 +1,41 @@
+% RES = ZCONV2(MTX1, MTX2, CTR)
+%
+% Convolution of two matrices, with boundaries handled as if the larger mtx
+% lies in a sea of zeros. Result will be of size of LARGER vector.
+% 
+% The origin of the smaller matrix is assumed to be its center.
+% For even dimensions, the origin is determined by the CTR (optional) 
+% argument:
+%      CTR   origin
+%       0     DIM/2      (default)
+%       1     (DIM/2)+1  (behaves like conv2(mtx1,mtx2,'same'))
+
+% Eero Simoncelli, 2/97.
+
+function c = zconv2(a,b,ctr)
+
+if (exist('ctr') ~= 1)
+  ctr = 0;
+end
+
+if (( size(a,1) >= size(b,1) ) & ( size(a,2) >= size(b,2) ))
+    large = a; small = b;
+elseif  (( size(a,1) <= size(b,1) ) & ( size(a,2) <= size(b,2) ))
+    large = b; small = a;
+else
+  error('one arg must be larger than the other in both dimensions!');
+end
+
+ly = size(large,1);
+lx = size(large,2);
+sy = size(small,1);
+sx = size(small,2);
+
+%% These values are the index of the small mtx that falls on the
+%% border pixel of the large matrix when computing the first
+%% convolution response sample:
+sy2 = floor((sy+ctr+1)/2);
+sx2 = floor((sx+ctr+1)/2);
+
+clarge = conv2(large,small);
+c = clarge(sy2:ly+sy2-1, sx2:lx+sx2-1);