'**SUMMARY**
This method applies a low pass DFT filter. This filter enhances
the low frequencies and removes the high frequency signals. This has
the effect of reducing noise. The frequencies are defined as going between
0.00 and 1.00 and where 0 is the lowest frequency in the image and 1.0 is
the highest possible frequencies. Each of the frequencies are defined
with respect to the horizontal and vertical signal. This filter
isn\'t perfect and has a harsh cutoff that causes ringing artifacts.
**PARAMETERS**
* *xCutoff* - The horizontal frequency at which we perform the cutoff. A separate
frequency can be used for the b,g, and r signals by providing a
list of values. The frequency is defined between zero to one,
where zero is constant component and 1 is the highest possible
frequency in the image.
* *yCutoff* - The cutoff frequencies in the y direction. If none are provided
we use the same values as provided for x.
* *grayscale* - if this value is True we perfrom the operation on the DFT of the gray
version of the image and the result is gray image. If grayscale is true
we perform the operation on each channel and the recombine them to create
the result.
**RETURNS**
A SimpleCV Image after applying the filter.
**EXAMPLE**
>>> img = Image("SimpleCV/sampleimages/RedDog2.jpg")
>>> img.getDFTLogMagnitude().show()
>>> lpf = img.lowPassFilter([0.2,0.2,0.05])
>>> lpf.show()
>>> lpf.getDFTLogMagnitude().show()
**NOTES**
This filter is far from perfect and will generate a lot of ringing artifacts.
See: http://en.wikipedia.org/wiki/Ringing_(signal)
See: http://en.wikipedia.org/wiki/Low-pass_filter
**SEE ALSO**
:py:meth:`rawDFTImage`
:py:meth:`getDFTLogMagnitude`
:py:meth:`applyDFTFilter`
:py:meth:`highPassFilter`
:py:meth:`lowPassFilter`
:py:meth:`bandPassFilter`
:py:meth:`InverseDFT`
:py:meth:`applyButterworthFilter`
:py:meth:`InverseDFT`
:py:meth:`applyGaussianFilter`
:py:meth:`applyUnsharpMask`'

def lowPassFilter(self, xCutoff, yCutoff=None, grayscale=False):

    if isinstance(xCutoff, float):
        xCutoff = [xCutoff, xCutoff, xCutoff]
    if isinstance(yCutoff, float):
        yCutoff = [yCutoff, yCutoff, yCutoff]
    if (yCutoff is None):
        yCutoff = [xCutoff[0], xCutoff[1], xCutoff[2]]
    for i in range(0, len(xCutoff)):
        xCutoff[i] = self._boundsFromPercentage(xCutoff[i], self.width)
        yCutoff[i] = self._boundsFromPercentage(yCutoff[i], self.height)
    filter = None
    h = self.height
    w = self.width
    if grayscale:
        filter = cv.CreateImage((self.width, self.height), cv.IPL_DEPTH_8U, 1)
        cv.Zero(filter)
        cv.Rectangle(filter, (0, 0), (xCutoff[0], yCutoff[0]), 255, thickness=(-1))
        cv.Rectangle(filter, (0, (h - yCutoff[0])), (xCutoff[0], h), 255, thickness=(-1))
        cv.Rectangle(filter, ((w - xCutoff[0]), 0), (w, yCutoff[0]), 255, thickness=(-1))
        cv.Rectangle(filter, ((w - xCutoff[0]), (h - yCutoff[0])), (w, h), 255, thickness=(-1))
    else:
        filterB = cv.CreateImage((self.width, self.height), cv.IPL_DEPTH_8U, 1)
        filterG = cv.CreateImage((self.width, self.height), cv.IPL_DEPTH_8U, 1)
        filterR = cv.CreateImage((self.width, self.height), cv.IPL_DEPTH_8U, 1)
        cv.Zero(filterB)
        cv.Zero(filterG)
        cv.Zero(filterR)
        temp = [filterB, filterG, filterR]
        i = 0
        for f in temp:
            cv.Rectangle(f, (0, 0), (xCutoff[i], yCutoff[i]), 255, thickness=(-1))
            cv.Rectangle(f, (0, (h - yCutoff[i])), (xCutoff[i], h), 255, thickness=(-1))
            cv.Rectangle(f, ((w - xCutoff[i]), 0), (w, yCutoff[i]), 255, thickness=(-1))
            cv.Rectangle(f, ((w - xCutoff[i]), (h - yCutoff[i])), (w, h), 255, thickness=(-1))
            i = (i + 1)
        filter = cv.CreateImage((self.width, self.height), cv.IPL_DEPTH_8U, 3)
        cv.Merge(filterB, filterG, filterR, None, filter)
    scvFilt = Image(filter)
    retVal = self.applyDFTFilter(scvFilt, grayscale)
    return retVal
