WOLFRAM

Wolfram Language & System Documentation Center

ListDeconvolve[ker,list]

gives a deconvolution of list using kernel ker.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Options  
MaxIterations  
Method  
Padding  
Applications  
Properties & Relations  
Possible Issues  
Neat Examples  
See Also
Related Guides
History
Cite this Page

ListDeconvolve

ListDeconvolve[ker,list]

gives a deconvolution of list using kernel ker.

Details and Options

  • The arguments ker and list in ListDeconvolve[ker,list] can be real numerical arrays of any rank, and ker cannot be larger than list in any dimension.
  • The following options can be given:
  • Method "DampedLS"deconvolution method to be used
    Padding "Reversed"padding to use for values beyond the original data
    MaxIterations 10number of iterations to try
  • If the elements of list are exact numbers, ListDeconvolve begins by applying N to them.
  • For a full documentation of available settings, see the reference page for ImageDeconvolve.

Examples

open all close all

Basic Examples  (2)

Create a 2D array and convolve it with a Gaussian kernel:

Wolfram Language code: data = ImageData[[image]]; ArrayPlot[blurred = ListConvolve[GaussianMatrix[4], data, 4, 1]]

Deconvolve the array:

Wolfram Language code: ArrayPlot[ListDeconvolve[GaussianMatrix[4], blurred]]

Deconvolve a 3D array:

Wolfram Language code: data = ImageData[[image]];
Wolfram Language code: ListDeconvolve[GaussianMatrix[{{2, 2, 2}}], data]//Image3D

Options  (4)

MaxIterations  (1)

Create a 2D array and convolve it with a Gaussian kernel:

Wolfram Language code: data = ImageData[[image]]; ker = GaussianMatrix[4]; ArrayPlot[blurred = ListConvolve[ker, data, 4, 1]]

By default, iterative methods run 10 iterations:

Wolfram Language code: ArrayPlot[ListDeconvolve[ker, blurred, Method -> {"RichardsonLucy", "Preconditioned" -> False}]]

Specify maximum number of iterations:

Wolfram Language code: ArrayPlot[ListDeconvolve[ker, blurred, Method -> {"RichardsonLucy", "Preconditioned" -> False}, MaxIterations -> 100]]

Method  (2)

Deconvolve a signal with different levels of regularization:

Wolfram Language code: data = {0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.5, 0.5, 0.5, 0.5, 0, 0, 0, 0, 0, 0, 0, 0}; conv = ListConvolve[ker = GaussianMatrix[{{3}}], data, 4] + 0.02 * RandomReal[NormalDistribution[], Length[data]]; ker = GaussianMatrix[{{3}}];GraphicsRow[ListLinePlot[{#, conv}, PlotRange -> All, AspectRatio -> 1 / 3]& /@ {ListDeconvolve[ker, conv, Method -> {"DampedLS", 0.01}], ListDeconvolve[ker, conv, Method -> {"DampedLS", 0.1}], ListDeconvolve[ker, conv, Method -> {"DampedLS", 0.5}]}, ImageSize -> Large]

Use various methods to deconvolve a piecewise constant signal:

Wolfram Language code: data = {0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.5, 0.5, 0.5, 0.5, 0, 0, 0, 0, 0, 0, 0, 0}; conv = ListConvolve[ker = GaussianMatrix[{{3}}], data, 4] + 0.02 * RandomReal[NormalDistribution[], Length[data]]; ker = GaussianMatrix[{{3}}]; GraphicsRow[ListLinePlot[{Tooltip[#, "deblurred"], Tooltip[conv, "blurred"]}, PlotRange -> All, AspectRatio -> 1 / 3]& /@ {ListDeconvolve[ker, conv, Method -> {"DampedLS"}], ListDeconvolve[ker, conv, Method -> "Wiener"], ListDeconvolve[ker, conv, Method -> "TotalVariation"]}, ImageSize -> Large]

Padding  (1)

Generate blurred data:

Wolfram Language code: data = PadLeft[Table[IntegerDigits[3 ^ n, 2], {n, 100}]]; ker = GaussianMatrix[3]; Image[blurred = ListConvolve[ker, data]]

By default, "Reversed" padding is used:

Wolfram Language code: Image[ListDeconvolve[ker, blurred, Method -> "RichardsonLucy"]]

Use "Periodic" padding:

Wolfram Language code: Image[ListDeconvolve[ker, blurred, Method -> "RichardsonLucy", Padding -> "Periodic"]]

Applications  (2)

Deconvolve a piecewise constant signal that was blurred and corrupted by additive noise:

Wolfram Language code: data = {0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.5, 0.5, 0.5, 0.5, 0, 0, 0, 0, 0, 0, 0, 0}; conv = ListConvolve[ker = GaussianMatrix[{{3}}], data, 4] + 0.02 * RandomReal[NormalDistribution[], Length[data]]; deconv = ListDeconvolve[ker, conv, Method -> "TotalVariation"]; ListLinePlot[{Tooltip[data, "original"], Tooltip[conv, "blurred"], Tooltip[deconv, "deblurred"]}, PlotRange -> {-0.1, 1.2}]

Deconvolve a cellular automaton list:

Wolfram Language code: ca = CellularAutomaton[150, {{1}, 0}, 30]; ker = BoxMatrix[1] / 9; blurred = ListConvolve[ker, ca]; restored = ListDeconvolve[ker, blurred, Method -> "RichardsonLucy", MaxIterations -> 50]; ArrayPlot /@ {blurred, restored}

Properties & Relations  (2)

ListDeconvolve is an approximate inverse of ListConvolve:

Wolfram Language code: data = {0., 0., 1., 2., 1., 2., 1., 0., 0., 0.}; ker = {1 / 3, 1 / 3, 1 / 3}; conv = ListConvolve[ker, data, 2]
Wolfram Language code: deconv = ListDeconvolve[ker, conv, Method -> "RichardsonLucy"]

ImageDeconvolve can be used to deblur images:

Wolfram Language code: ImageDeconvolve[[image], DiskMatrix[3] / 37]

Possible Issues  (1)

Zero regularization values give rise to ringing artifacts:

Wolfram Language code: data = {0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.5, 0.5, 0.5, 0.5, 0, 0, 0, 0, 0, 0, 0, 0}; conv = ListConvolve[ker = GaussianMatrix[{{3}}], data, 4] + 0.02 * RandomReal[NormalDistribution[], Length[data]]; ker = GaussianMatrix[{{3}}]; ListLinePlot[{ListDeconvolve[ker, conv, Method -> {"Wiener", 0.0}], conv}, PlotRange -> All, AspectRatio -> 1 / 3]

Neat Examples  (1)

This generates blurry and noisy data:

Wolfram Language code: f = {6, 7, 2, 5, 1};h = {1, 1, 1} / 3.;n = {-0.05, 0.2, 0.1, -0.2, -0.1};
Wolfram Language code: g = ListConvolve[h, f, 2] + n

Compute 30 iterations of the Richardson–Lucy algorithm:

Wolfram Language code: tmp = Map[ListDeconvolve[h, g, Method -> "RichardsonLucy", MaxIterations -> #, Padding -> "Periodic"]&, Range[1, 30]];

Visualize the restoration process. The red dots show the original values of the signal:

Wolfram Language code: ListLinePlot[Transpose[tmp], PlotStyle -> StandardGray, PlotRange -> All, AspectRatio -> 2 / 3, Epilog -> {PointSize[Medium], {Blue, Point[Thread[{1, tmp[[1]]}]]}, {Red, Point[Thread[{30, f}]]}}]
Wolfram Research (2010), ListDeconvolve, Wolfram Language function, https://reference.wolfram.com/language/ref/ListDeconvolve.html.

Text

Wolfram Research (2010), ListDeconvolve, Wolfram Language function, https://reference.wolfram.com/language/ref/ListDeconvolve.html.

CMS

Wolfram Language. 2010. "ListDeconvolve." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/ListDeconvolve.html.

APA

Wolfram Language. (2010). ListDeconvolve. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/ListDeconvolve.html

BibTeX

@misc{reference.wolfram_2026_listdeconvolve, author="Wolfram Research", title="{ListDeconvolve}", year="2010", howpublished="\url{https://reference.wolfram.com/language/ref/ListDeconvolve.html}", note=[Accessed: 13-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_listdeconvolve, organization={Wolfram Research}, title={ListDeconvolve}, year={2010}, url={https://reference.wolfram.com/language/ref/ListDeconvolve.html}, note=[Accessed: 13-June-2026]}