def _stackFilters(self, flt1):
"""
**SUMMARY**
stack two filters of same size. channels don't matter.
**PARAMETERS**
* *flt1* - second filter to be stacked
**RETURNS**
DFT filter
"""
if isinstance(self._numpy, type(None)):
return flt1
if not self.size() == flt1.size():
warnings.warn("All the filters must be of same size")
return None
numpyflt = self._numpy
numpyflt1 = flt1._numpy
flt = np.dstack((numpyflt, numpyflt1))
stackedfilter = DFT(size=self.size(),
numpyarray=flt,
channels=self.channels + flt1.channels,
type=self._type,
frequency=self._freqpass)
return stackedfilter
def _stackFilters(self, flt1):
"""
**SUMMARY**
stack two filters of same size. channels don't matter.
**PARAMETERS**
* *flt1* - second filter to be stacked
**RETURNS**
DFT filter
"""
if isinstance(self._numpy, type(None)):
return flt1
if not self.size() == flt1.size():
warnings.warn("All the filters must be of same size")
return None
numpyflt = self._numpy
numpyflt1 = flt1._numpy
flt = np.dstack((numpyflt, numpyflt1))
stackedfilter = DFT(size=self.size(), numpyarray=flt,
channels=self.channels+flt1.channels,
type=self._type, frequency=self._freqpass)
return stackedfilter
def createButterworthFilter(self, dia=400, size=(64, 64), order=2, highpass=False):
"""
**SUMMARY**
Creates a butterworth filter of given size and order.
**PARAMETERS**
* *dia* - int - diameter of Gaussian filter
- list - provide a list of three diameters to create
a 3 channel filter
* *size* - size of the filter (width, height)
* *order* - order of the filter
* *highpass*: - bool
True: highpass filter
False: lowpass filter
**RETURNS**
DFT filter.
**EXAMPLE**
>>> flt = DFT.createButterworthfilter(100, (512, 512), order=3,
highpass=True)
>>> flt = DFT.createButterworthfilter([100, 120, 140], (512, 512),
order=3, highpass=False)
>>> img = Image('lenna')
>>> flt.applyFilter(img).show()
"""
if isinstance(dia, list):
if len(dia) != 3 and len(dia) != 1:
warnings.warn("diameter list must be of size 1 or 3")
return None
stackedfilter = DFT()
for d in dia:
stackedfilter = stackedfilter._stackFilters(self.createButterworthFilter(d, size, order, highpass))
image = Image(stackedfilter._numpy)
retVal = DFT(numpyarray=stackedfilter._numpy, image=image,
dia=dia, channels = len(dia), size=size,
type=stackedfilter._type, order=order,
frequency=stackedfilter._freqpass)
return retVal
freqpass = "******"
sz_x, sz_y = size
x0 = sz_x/2
y0 = sz_y/2
X, Y = np.meshgrid(np.arange(sz_x), np.arange(sz_y))
D = np.sqrt((X-x0)**2+(Y-y0)**2)
flt = 255/(1.0 + (D/dia)**(order*2))
if highpass:
frequency = "highpass"
flt = 255 - flt
img = Image(flt)
retVal = DFT(size=size, numpyarray=flt, image=img, dia=dia,
type="Butterworth", frequency=freqpass)
return retVal
def __add__(self, flt):
if not isinstance(flt, type(self)):
warnings.warn("Provide SimpleCV.DFT object")
return None
if self.size() != flt.size():
warnings.warn("Both SimpleCV.DFT object must have the same size")
return None
flt_numpy = self._numpy + flt._numpy
flt_image = Image(flt_numpy)
retVal = DFT(numpyarray=flt_numpy, image=flt_image, size=flt_image.size())
return retVal
def getNumpy(self):
"""
**SUMMARY**
Get the numpy array of the filter
**RETURNS**
numpy array of the filter.
**EXAMPLE**
>>> notch = DFT.createNotchFilter(dia1=200, cen=(200, 200),
size=(512, 512), type="highpass")
>>> notch.getNumpy()
"""
if isinstance(self._numpy, type(None)):
if isinstance(self._image, type(None)):
warnings.warn("Filter doesn't contain any image")
self._numpy = self._image.getNumpy()
return self._numpy
def getNumpy(self):
"""
**SUMMARY**
Get the numpy array of the filter
**RETURNS**
numpy array of the filter.
**EXAMPLE**
>>> notch = DFT.createNotchFilter(dia1=200, cen=(200, 200),
size=(512, 512), type="highpass")
>>> notch.getNumpy()
"""
if isinstance(self._numpy, type(None)):
if isinstance(self._image, type(None)):
warnings.warn("Filter doesn't contain any image")
self._numpy = self._image.getNumpy()
return self._numpy
def stackFilters(self, flt1, flt2):
"""
**SUMMARY**
Stack three signle channel filters of the same size to create
a 3 channel filter.
**PARAMETERS**
* *flt1* - second filter to be stacked
* *flt2* - thrid filter to be stacked
**RETURNS**
DFT filter
**EXAMPLE**
>>> flt1 = DFT.createGaussianFilter(dia=200, size=(380, 240))
>>> flt2 = DFT.createGaussianFilter(dia=100, size=(380, 240))
>>> flt2 = DFT.createGaussianFilter(dia=70, size=(380, 240))
>>> flt = flt1.stackFilters(flt2, flt3) # 3 channel filter
"""
if not (self.channels == 1 and flt1.channels == 1
and flt2.channels == 1):
warnings.warn("Filters must have only 1 channel")
return None
if not (self.size() == flt1.size() and self.size() == flt2.size()):
warnings.warn("All the filters must be of same size")
return None
numpyflt = self._numpy
numpyflt1 = flt1._numpy
numpyflt2 = flt2._numpy
flt = np.dstack((numpyflt, numpyflt1, numpyflt2))
img = Image(flt)
stackedfilter = DFT(size=self.size(),
numpyarray=flt,
image=img,
channels=3)
return stackedfilter
def getImage(self):
"""
**SUMMARY**
Get the SimpleCV Image of the filter
**RETURNS**
Image of the filter.
**EXAMPLE**
>>> notch = DFT.createNotchFilter(dia1=200, cen=(200, 200),
size=(512, 512), type="highpass")
>>> notch.getImage().show()
"""
print self._image
if isinstance(self._image, type(None)):
if isinstance(self._numpy, type(None)):
warnings.warn("Filter doesn't contain any image")
self._image = Image(self._numpy.astype(np.uint8))
return self._image
def applyFilter(self, image, grayscale=False):
"""
**SUMMARY**
Apply the DFT filter to given image.
**PARAMETERS**
* *image* - SimpleCV.Image image
* *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**
Filtered Image.
**EXAMPLE**
>>> notch = DFT.createNotchFilter(dia1=200, cen=(200, 200),
size=(512, 512), type="highpass")
>>> img = Image('lenna')
>>> notch.applyFilter(img).show()
"""
if self.width == 0 or self.height == 0:
warnings.warn("Empty Filter. Returning the image.")
return image
w, h = image.size()
if grayscale:
image = image.toGray()
print self._numpy.dtype, "gray"
fltImg = Image(self._numpy)
if fltImg.size() != image.size():
fltImg = fltImg.resize(w, h)
filteredImage = image.applyDFTFilter(fltImg, grayscale)
return filteredImage
def getImage(self):
"""
**SUMMARY**
Get the SimpleCV Image of the filter
**RETURNS**
Image of the filter.
**EXAMPLE**
>>> notch = DFT.createNotchFilter(dia1=200, cen=(200, 200),
size=(512, 512), type="highpass")
>>> notch.getImage().show()
"""
print self._image
if isinstance(self._image, type(None)):
if isinstance(self._numpy, type(None)):
warnings.warn("Filter doesn't contain any image")
self._image = Image(self._numpy.astype(np.uint8))
return self._image
def applyFilter(self, image, grayscale=False):
"""
**SUMMARY**
Apply the DFT filter to given image.
**PARAMETERS**
* *image* - SimpleCV.Image image
* *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**
Filtered Image.
**EXAMPLE**
>>> notch = DFT.createNotchFilter(dia1=200, cen=(200, 200),
size=(512, 512), type="highpass")
>>> img = Image('lenna')
>>> notch.applyFilter(img).show()
"""
if self.width == 0 or self.height == 0:
warnings.warn("Empty Filter. Returning the image.")
return image
w, h = image.size()
if grayscale:
image = image.toGray()
print self._numpy.dtype, "gray"
fltImg = Image(self._numpy)
if fltImg.size() != image.size():
fltImg = fltImg.resize(w, h)
filteredImage = image.applyDFTFilter(fltImg, grayscale)
return filteredImage
def stackFilters(self, flt1, flt2):
"""
**SUMMARY**
Stack three signle channel filters of the same size to create
a 3 channel filter.
**PARAMETERS**
* *flt1* - second filter to be stacked
* *flt2* - thrid filter to be stacked
**RETURNS**
DFT filter
**EXAMPLE**
>>> flt1 = DFT.createGaussianFilter(dia=200, size=(380, 240))
>>> flt2 = DFT.createGaussianFilter(dia=100, size=(380, 240))
>>> flt2 = DFT.createGaussianFilter(dia=70, size=(380, 240))
>>> flt = flt1.stackFilters(flt2, flt3) # 3 channel filter
"""
if not(self.channels == 1 and flt1.channels == 1 and flt2.channels == 1):
warnings.warn("Filters must have only 1 channel")
return None
if not (self.size() == flt1.size() and self.size() == flt2.size()):
warnings.warn("All the filters must be of same size")
return None
numpyflt = self._numpy
numpyflt1 = flt1._numpy
numpyflt2 = flt2._numpy
flt = np.dstack((numpyflt, numpyflt1, numpyflt2))
img = Image(flt)
stackedfilter = DFT(size=self.size(), numpyarray=flt, image=img, channels=3)
return stackedfilter
def createNotchFilter(self,
dia1,
dia2=None,
cen=None,
size=(64, 64),
type="lowpass"):
"""
**SUMMARY**
Creates a disk shaped notch filter of given diameter at given center.
**PARAMETERS**
* *dia1* - int - diameter of the disk shaped notch
- list - provide a list of three diameters to create
a 3 channel filter
* *dia2* - int - outer diameter of the disk shaped notch
used for bandpass filter
- list - provide a list of three diameters to create
a 3 channel filter
* *cen* - tuple (x, y) center of the disk shaped notch
if not provided, it will be at the center of the
filter
* *size* - size of the filter (width, height)
* *type*: - lowpass or highpass filter
**RETURNS**
DFT notch filter
**EXAMPLE**
>>> notch = DFT.createNotchFilter(dia1=200, cen=(200, 200),
size=(512, 512), type="highpass")
>>> notch = DFT.createNotchFilter(dia1=200, dia2=300, cen=(200, 200),
size=(512, 512))
>>> img = Image('lenna')
>>> notch.applyFilter(img).show()
"""
if isinstance(dia1, list):
if len(dia1) != 3 and len(dia1) != 1:
warnings.warn("diameter list must be of size 1 or 3")
return None
if isinstance(dia2, list):
if len(dia2) != 3 and len(dia2) != 1:
warnings.warn("diameter list must be of size 3 or 1")
return None
if len(dia2) == 1:
dia2 = [dia2[0]] * len(dia1)
else:
dia2 = [dia2] * len(dia1)
if isinstance(cen, list):
if len(cen) != 3 and len(cen) != 1:
warnings.warn("center list must be of size 3 or 1")
return None
if len(cen) == 1:
cen = [cen[0]] * len(dia1)
else:
cen = [cen] * len(dia1)
stackedfilter = DFT()
for d1, d2, c in zip(dia1, dia2, cen):
stackedfilter = stackedfilter._stackFilters(
self.createNotchFilter(d1, d2, c, size, type))
image = Image(stackedfilter._numpy)
retVal = DFT(numpyarray=stackedfilter._numpy,
image=image,
dia=dia1 + dia2,
channels=len(dia1),
size=size,
type=stackedfilter._type,
frequency=stackedfilter._freqpass)
return retVal
w, h = size
if cen is None:
cen = (w / 2, h / 2)
a, b = cen
y, x = np.ogrid[-a:w - a, -b:h - b]
r = dia1 / 2
mask = x * x + y * y <= r * r
flt = np.ones((w, h))
flt[mask] = 255
if type == "highpass":
flt = 255 - flt
if dia2 is not None:
a, b = cen
y, x = np.ogrid[-a:w - a, -b:h - b]
r = dia2 / 2
mask = x * x + y * y <= r * r
flt1 = np.ones((w, h))
flt1[mask] = 255
flt1 = 255 - flt1
flt = flt + flt1
np.clip(flt, 0, 255)
type = "bandpass"
img = Image(flt)
notchfilter = DFT(size=size,
numpyarray=flt,
image=img,
dia=dia1,
type="Notch",
frequency=type)
return notchfilter
def createHighpassFilter(self, xCutoff, yCutoff=None, size=(64, 64)):
"""
**SUMMARY**
Creates a highpass filter of given size and order.
**PARAMETERS**
* *xCutoff* - int - horizontal cut off frequency
- list - provide a list of three cut off frequencies
to create a 3 channel filter
* *yCutoff* - int - vertical cut off frequency
- list - provide a list of three cut off frequencies
to create a 3 channel filter
* *size* - size of the filter (width, height)
**RETURNS**
DFT filter.
**EXAMPLE**
>>> flt = DFT.createHighpassFilter(xCutoff=75, size=(320, 280))
>>> flt = DFT.createHighpassFilter(xCutoff=[75], size=(320, 280))
>>> flt = DFT.createHighpassFilter(xCutoff=[75, 100, 120],
size=(320, 280))
>>> flt = DFT.createHighpassFilter(xCutoff=75, yCutoff=35,
size=(320, 280))
>>> flt = DFT.createHighpassFilter(xCutoff=[75], yCutoff=[35],
size=(320, 280))
>>> flt = DFT.createHighpassFilter(xCutoff=[75, 100, 125], yCutoff=35,
size=(320, 280))
>>> # yCutoff will be [35, 35, 35]
>>> flt = DFT.createHighpassFilter(xCutoff=[75, 113, 124],
yCutoff=[35, 45, 90],
size=(320, 280))
>>> img = Image('lenna')
>>> flt.applyFilter(img).show()
"""
if isinstance(xCutoff, list):
if len(xCutoff) != 3 and len(xCutoff) != 1:
warnings.warn("xCutoff list must be of size 3 or 1")
return None
if isinstance(yCutoff, list):
if len(yCutoff) != 3 and len(yCutoff) != 1:
warnings.warn("yCutoff list must be of size 3 or 1")
return None
if len(yCutoff) == 1:
yCutoff = [yCutoff[0]] * len(xCutoff)
else:
yCutoff = [yCutoff] * len(xCutoff)
stackedfilter = DFT()
for xfreq, yfreq in zip(xCutoff, yCutoff):
stackedfilter = stackedfilter._stackFilters(
self.createHighpassFilter(xfreq, yfreq, size))
image = Image(stackedfilter._numpy)
retVal = DFT(numpyarray=stackedfilter._numpy,
image=image,
xCutoffHigh=xCutoff,
yCutoffHigh=yCutoff,
channels=len(xCutoff),
size=size,
type=stackedfilter._type,
order=self._order,
frequency=stackedfilter._freqpass)
return retVal
lowpass = self.createLowpassFilter(xCutoff, yCutoff, size)
w, h = lowpass.size()
flt = lowpass._numpy
flt = 255 - flt
img = Image(flt)
highpassFilter = DFT(size=size,
numpyarray=flt,
image=img,
type="Highpass",
xCutoffHigh=xCutoff,
yCutoffHigh=yCutoff,
frequency="highpass")
return highpassFilter
def createNotchFilter(self, dia1, dia2=None, cen=None, size=(64, 64), type="lowpass"):
"""
**SUMMARY**
Creates a disk shaped notch filter of given diameter at given center.
**PARAMETERS**
* *dia1* - int - diameter of the disk shaped notch
- list - provide a list of three diameters to create
a 3 channel filter
* *dia2* - int - outer diameter of the disk shaped notch
used for bandpass filter
- list - provide a list of three diameters to create
a 3 channel filter
* *cen* - tuple (x, y) center of the disk shaped notch
if not provided, it will be at the center of the
filter
* *size* - size of the filter (width, height)
* *type*: - lowpass or highpass filter
**RETURNS**
DFT notch filter
**EXAMPLE**
>>> notch = DFT.createNotchFilter(dia1=200, cen=(200, 200),
size=(512, 512), type="highpass")
>>> notch = DFT.createNotchFilter(dia1=200, dia2=300, cen=(200, 200),
size=(512, 512))
>>> img = Image('lenna')
>>> notch.applyFilter(img).show()
"""
if isinstance(dia1, list):
if len(dia1) != 3 and len(dia1) != 1:
warnings.warn("diameter list must be of size 1 or 3")
return None
if isinstance(dia2, list):
if len(dia2) != 3 and len(dia2) != 1:
warnings.warn("diameter list must be of size 3 or 1")
return None
if len(dia2) == 1:
dia2 = [dia2[0]]*len(dia1)
else:
dia2 = [dia2]*len(dia1)
if isinstance(cen, list):
if len(cen) != 3 and len(cen) != 1:
warnings.warn("center list must be of size 3 or 1")
return None
if len(cen) == 1:
cen = [cen[0]]*len(dia1)
else:
cen = [cen]*len(dia1)
stackedfilter = DFT()
for d1, d2, c in zip(dia1, dia2, cen):
stackedfilter = stackedfilter._stackFilters(self.createNotchFilter(d1, d2, c, size, type))
image = Image(stackedfilter._numpy)
retVal = DFT(numpyarray=stackedfilter._numpy, image=image,
dia=dia1+dia2, channels = len(dia1), size=size,
type=stackedfilter._type,
frequency=stackedfilter._freqpass)
return retVal
w, h = size
if cen is None:
cen = (w/2, h/2)
a, b = cen
y, x = np.ogrid[-a:w-a, -b:h-b]
r = dia1/2
mask = x*x + y*y <= r*r
flt = np.ones((w, h))
flt[mask] = 255
if type == "highpass":
flt = 255-flt
if dia2 is not None:
a, b = cen
y, x = np.ogrid[-a:w-a, -b:h-b]
r = dia2/2
mask = x*x + y*y <= r*r
flt1 = np.ones((w, h))
flt1[mask] = 255
flt1 = 255 - flt1
flt = flt + flt1
np.clip(flt, 0, 255)
type = "bandpass"
img = Image(flt)
notchfilter = DFT(size=size, numpyarray=flt, image=img, dia=dia1,
type="Notch", frequency=type)
return notchfilter
def createHighpassFilter(self, xCutoff, yCutoff=None, size=(64, 64)):
"""
**SUMMARY**
Creates a highpass filter of given size and order.
**PARAMETERS**
* *xCutoff* - int - horizontal cut off frequency
- list - provide a list of three cut off frequencies
to create a 3 channel filter
* *yCutoff* - int - vertical cut off frequency
- list - provide a list of three cut off frequencies
to create a 3 channel filter
* *size* - size of the filter (width, height)
**RETURNS**
DFT filter.
**EXAMPLE**
>>> flt = DFT.createHighpassFilter(xCutoff=75, size=(320, 280))
>>> flt = DFT.createHighpassFilter(xCutoff=[75], size=(320, 280))
>>> flt = DFT.createHighpassFilter(xCutoff=[75, 100, 120],
size=(320, 280))
>>> flt = DFT.createHighpassFilter(xCutoff=75, yCutoff=35,
size=(320, 280))
>>> flt = DFT.createHighpassFilter(xCutoff=[75], yCutoff=[35],
size=(320, 280))
>>> flt = DFT.createHighpassFilter(xCutoff=[75, 100, 125], yCutoff=35,
size=(320, 280))
>>> # yCutoff will be [35, 35, 35]
>>> flt = DFT.createHighpassFilter(xCutoff=[75, 113, 124],
yCutoff=[35, 45, 90],
size=(320, 280))
>>> img = Image('lenna')
>>> flt.applyFilter(img).show()
"""
if isinstance(xCutoff, list):
if len(xCutoff) != 3 and len(xCutoff) != 1:
warnings.warn("xCutoff list must be of size 3 or 1")
return None
if isinstance(yCutoff, list):
if len(yCutoff) != 3 and len(yCutoff) != 1:
warnings.warn("yCutoff list must be of size 3 or 1")
return None
if len(yCutoff) == 1:
yCutoff = [yCutoff[0]]*len(xCutoff)
else:
yCutoff = [yCutoff]*len(xCutoff)
stackedfilter = DFT()
for xfreq, yfreq in zip(xCutoff, yCutoff):
stackedfilter = stackedfilter._stackFilters(
self.createHighpassFilter(xfreq, yfreq, size))
image = Image(stackedfilter._numpy)
retVal = DFT(numpyarray=stackedfilter._numpy, image=image,
xCutoffHigh=xCutoff, yCutoffHigh=yCutoff,
channels=len(xCutoff), size=size,
type=stackedfilter._type, order=self._order,
frequency=stackedfilter._freqpass)
return retVal
lowpass = self.createLowpassFilter(xCutoff, yCutoff, size)
w, h = lowpass.size()
flt = lowpass._numpy
flt = 255 - flt
img = Image(flt)
highpassFilter = DFT(size=size, numpyarray=flt, image=img,
type="Highpass", xCutoffHigh=xCutoff,
yCutoffHigh=yCutoff, frequency="highpass")
return highpassFilter
