Linux  Mac OS X  Windows 

(!)  Not supported (yet) 
proxTV is a toolbox implementing blazing fast implementations of Total Variation proximity operators, which form the basic building blocks for applications such as image denoising, image deconvolution, image inpainting, video denoising, or fused lasso models, to name a few. While the core algorithms are implemented in C to achieve top efficiency, Matlab and Python interfaces are provided for ease of use.
Some examples of applications using proxTV:
and others, such as Fused Lasso signal filtering, Fused Lasso classification and regression, lpnorm signal filtering, weighted image denosing, video denosing, tensor denoising, ...
More technically, the library provides efficient solvers for the following Total Variation proximity problems:
Python interface
Install
pip install proxtv
Install from source
If the above doesn't work or you are using an unsupported operative system or Python version, you can install proxTV from souce.
The following system prerequisites are necessary

gcc. In Ubuntu, run
apt install buildessential

BLAS developer libraries. In Ubuntu, run
apt install libblasdev

LAPACK developer libraries. In Ubuntu, run
apt install liblapackdev
Then you can clone this repository and install the library with
python setup.py install
Additionally, if you would like to run the provided demos you will also require the following packages:
Usage
Import proxTV Python package as
import prox_tv as ptv
or
from prox_tv import *
for direct access to all the package routines.
The documentation of use of the package functions is maintained online at http://pythonhosted.org/prox_tv/.
Matlab interface
Quick start guide
To install proxTV clone this repository and run install
at the Matlab prompt once located at proxTV folder. If any problem arises please refer to the "Installation" subsection.
After that the TV solver can be invoked easily through the general purpose "TV" function. For instance,
TV(X,lambda)
solves TV for X signal and lambda regularizer. The dimensionality of X is automatically checked and an adequate solver is applied.
To solve TV for a general TVLp norm just add the value of p as a third argument,
TV(X,lambda,p)
Weighted versions of TV can also be solved by using exactly the same interface, but providing a vector of lambda weights instead of a scalar. For multidimensional signals the relevant weights are provided as a cell array; the "Usage" section for more details on this and more advanced uses of toolbox.
Installation
To install proxTV follow the steps:
 Open Matlab.
 Change directory to the folder where this README file is located.
 Type: "install"
 After compilation the message "proxTV successfully installed" will appear. If instead an error message shows up, check your mex compiler configuration (type "mex setup"). If the error was produced by the "openmp" library, you might need to install it, or you can install proxTV with no multithread features by typing "install(1)".
 The install script automatically adds the relevant proxTV folders to your Matlab path. If this were to fail for some reason, you should manually add the /matlab subfolder to your Matlab path. You can do this e.g. by using the "pathtool()" utility. You may also add the /matlab/demos subfolder to try out the included demos.
Note: this interface has only been tested under Linux. Installation might require LAPACK (http://www.netlib.org/lapack/) and BLAS (http://www.netlib.org/blas/) libraries.
Usage
Two main functions conform the Matlab interface of proxTV: TV and TVgen. The first one provides basic options over the Total Variation problem, while the second one allows a more advanced configuration. In general, the TV function should suffice for most uses.
TV
Solves Total Variation proximity operators for ndimensional signals, applying a TVLp norm. The inputs and outputs of this function are:
[x,info] = TV(y,lambda,p,threads)
Inputs
 y: input of the proximity operator.
 lambda: premultiplier of the norm.
 (Optional) p: norm. Default is p = 1.
 (Optional) threads: number of threads (default 1). Used only for 2D or higherdimensional signals.
Outputs
 x: solution of the proximity problem.
 info: statistical info of the run algorithm:
 info.iters: number of iterations run (major iterations for the 2D case)
 info.stop: value of the stopping criterion.
For 1dimensional signals the problem solved is
Using p=1 results in the standard Total Variation regularizer, which generates a "blocky" reconstruction of the signal. Using p=2 instead produces a smoother reconstruction.
For 2dimensional signals (e.g. images) the problem solved is
where X(i,:) is ith row of X and X(:,j) is the jth column of X. Using p=1 results in an anisotropic denoising filter.
For Ddimensional signals the problem being solved becomes
where X[d,i] is the ith 1dimensional fiber of X along its dth dimension, and TV1D denotes the standard 1dimensional Total Variation penalty applied over such fiber.
If a vector of weights w is provided for the lambda parameter instead of an scalar value, the special weighted version of TV is solved,
were each difference among signal entries x_i and x_(i1) is penalized using a different weight w_i.
In the case of 2D signals the weighted problem is
Weight matrices are provided in the TV function as the lambda parameter through a cell array in the form {w, v} (see the examples in the "Examples" section)
TVgen
Solves a generalized TV proximity operator for a multidimensional signal, in the form
, with X(di) every possible 1dimensional slice of X following dimension di.
The inputs and outputs of this function are:
[x,info] = TVgen(y,lambdas,ds,norms,threads)
Inputs:
 y: input signal.
 lambdas: vector of lambda penalties of each penalty term.
 ds: vector of dimensions of application of each penalty term.
 norms: vector of norms of each penalty term.
 (Optional) threads: number of threads to use (default: 1)
Outputs:
 x: solution of the proximity problem.
 info: statistical info of the run algorithm:
 info.iters: number of major iterations run.
 info.stop: value of the stopping criterion.
When possible, TV should be preferred. See the Examples section next for some specific examples on using this function.
Examples
1D examples
Filter 1D signal using TVL1 norm:
TV(x,lambda)
Filter 1D signal using weighted TVL1 norm (for x vector of length N, weights vector of length N1)
TV(x,weights)
Filter 1D signal using TVL2 norm:
TV(x,lambda,2)
Filter 1D signal using both TVL1 and TVL2 norms:
TVgen(X,[lambda1 lambda2],[1 1],[1 2])
2D examples
Filter 2D signal using TVL1 norm (image denoising):
TV(X,lambda)
or
TVgen(X,[lambda lambda],[1 2],[1 1])
Filter 2D signal using TVL2 norm:
TV(X,lambda,2)
or
TVgen(X,[lambda lambda],[1 2],[2 2])
Filter 2D signal using 4 parallel threads (last argument):
TV(X,lambda,1,4)
or
TVgen(X,[lambda lambda],[1 2],[1 1],4)
Filter 2D signal using TVL1 norm for the rows, TVL2 for the columns, and different penalties:
TVgen(X,[lambdaRows lambdaCols],[1 2],[1 2])
Filter 2D signal using both TVL1 and TVL2 norms:
TVgen(X,[lambda1 lambda1 lambda2 lambda2],[1 2 1 2],[1 1 2 2])
Filter 2D signal using weighted TVL1 norm (for X image of size MxN, W1 weights of size (M1)xN, W2 weights of size Mx(N1))
TV(X, {W1, W2})
3D examples
Filter 3D signal using TVL1 norm (video denoising):
TV(X,lambda)
or
TVgen(X,[lambda lambda lambda],[1 2 3],[1 1 1])
Filter 3D signal using TVL2 norm, not penalizing over the second dimension:
TVgen(X,[lambda lambda],[1 3],[2 2])
Demos
Some demos in the form of both Matlab and Python scripts showing how to work with proxTV are included in the subfolders /matlab/demos and /prox_tv/demos, respectively. They are:
 demo_filter_signal: TVL1, TVL2 and weighted TVL1 filtering of 1dimensional signals.
 demo_filter_image: TVL1 filtering of 2dimensional image.
 demo_filter_image_color: TVL1 filtering of 3dimensional image (length, width and color).
 demo_filter_image_threads: multithread TVL1 filtering of 2dimensional image.
 demo_filter_image_weighted: weighted TVL1 filtering of 2dimensional image.
Notes on Mac OS X
Under Mac OS X some numerical accuracy issues have been observed for TVL2 solvers. This is due to lowlevel Mac numerical libraries, and may produce failures in some of proxTV tests. Other solvers should work OK.
Referencing
If you find this toolbox useful please reference the following papers:

Fast Newtontype Methods for Total Variation Regularization. Álvaro Barbero, Suvrit Sra. ICML 2011 proceedings.

Modular proximal optimization for multidimensional totalvariation regularization. Álvaro Barbero, Suvrit Sra. http://arxiv.org/abs/1411.0589
whose Bibtex entries are
@inproceedings{conf/icml/Barbero11,
addedat = {20111216T00:00:00.000+0100},
author = {Barbero, \'Alvaro and Sra, Suvrit},
biburl = {http://www.bibsonomy.org/bibtex/214ce9f5c15d1d462bd264d8af9e4c3c7/dblp},
booktitle = {ICML},
crossref = {conf/icml/2011},
editor = {Getoor, Lise and Scheffer, Tobias},
interhash = {5d6359b6c7f4d0fb6de36aada6827a3e},
intrahash = {14ce9f5c15d1d462bd264d8af9e4c3c7},
keywords = {dblp},
pages = {313320},
publisher = {Omnipress},
timestamp = {20111216T00:00:00.000+0100},
title = {Fast Newtontype Methods for Total Variation Regularization.},
url = {http://dblp.unitrier.de/db/conf/icml/icml2011.html#JimenezS11},
year = 2011
}
@Article{barberoTV14,
Title = {Modular proximal optimization for multidimensional totalvariation regularization},
Author = {\'Alvaro Barbero and Suvrit Sra},
Year = {2014},
Url = {http://arxiv.org/abs/1411.0589}
}
Acknowledgements
We wish to thank the following people for helping us in debugging and extending the toolbox:
 Zico Kolter for pointing out a bug in our Projected Newton method.
 Sesh Kumar for spotting and correcting a bug in our weighted 1DTV method.
 Josip Djolonga for implementing the Python bindings.
 Fabian Pedregosa for improving MacOS support.