def process_image(imagename, resultname='temp.sift', dense=False):    
    """ process an image and save the results in a .key ascii file"""
    print "working on ", imagename
    if dense == False:
        if imagename[-3:] != 'pgm':
            #create a pgm file, image is resized, if it is too big.
            # sift returns an error if more than 8000 features are found
            size = (MAXSIZE, MAXSIZE)
            im = Image.open(imagename).convert('L')
            im.thumbnail(size, Image.ANTIALIAS)
            im.save('tmp.pgm')
            imagename = 'tmp.pgm'
        
        #check if linux or windows 
        if os.name == "posix":
            cmmd = "./sift <" + imagename + ">" + resultname
            print cmmd
        else:
            cmmd = "siftWin32 <" + imagename + ">" + resultname
        
        os.system(cmmd)
        if os.path.getsize(resultname) == 0:
            raise IOError("extracting SIFT features failed " + resultname)

    else:
        import vlfeat

        # defines how dense the grid is
        size = (150, 150)
        step = 10
        
        im = Image.open(imagename).resize(size, Image.ANTIALIAS)
        im_array = numpy.asarray(im)
        if im_array.ndim == 3:
            im_gray = vlfeat.vl_rgb2gray(im_array)
        elif im_array.ndim == 2:
            im_gray = im_array
        else:
            raise IOError("Not enough dims found in image " + resultname)
        

        locs, int_descriptors = vlfeat.vl_dsift(im_gray, step=step, verbose=VERBOSE)
        nfeatures = int_descriptors.shape[1]
        padding = numpy.zeros((2, nfeatures))
        locs = numpy.vstack((locs, padding))
        header = ' '.join([str(nfeatures), str(128)])
        temp = int_descriptors.astype('float')  # convert descriptors to float
        descriptors = temp[:]
        with open(resultname, 'wb') as f:
            cPickle.dump([locs.T, descriptors.T], f, protocol=cPickle.HIGHEST_PROTOCOL)
        print "features saved in", resultname
        if WRITE_VERBOSE:
            with open(resultname, 'w') as f:
                f.write(header)
                f.write("\n")
                for i in range(nfeatures):
                    f.write(' '.join(map(str, locs[:, i])))
                    f.write("\n")
                    f.write(' '.join(map(str, descriptors[:, i])))
                    f.write("\n")
	def extract_feature_vector(self):
		img = imread(self.image.get_path()) if self.memory == False else self.image
		imgResized = resize(img, (300,250))
		grayScaleImg = vl_rgb2gray(imgResized).astype('uint8')
		histEqualizedImage = equalizeHist(grayScaleImg)
		sizeOfSpatialBins = 8
		step = 10
		fast = False #if set to True it uses a flat window rather than a Gaussian window
		verbose = False
		norm = False
		bounds = -1
		frames ,descriptors = vl_dsift(histEqualizedImage,step,bounds,sizeOfSpatialBins,fast,verbose,norm)
		return descriptors.transpose().astype('float32')
Esempio n. 3
0
def vl_phow(im,
            verbose=True,
            fast=True,
            sizes=[4, 6, 8, 10],
            step=2,
            color='rgb',
            floatdescriptors=False,
            magnif=6,
            windowsize=1.5,
            contrastthreshold=0.005):

    opts = Options(verbose, fast, sizes, step, color, floatdescriptors, magnif,
                   windowsize, contrastthreshold)
    dsiftOpts = DSiftOptions(opts)

    # make sure image is float, otherwise segfault
    im = array(im, 'float32')

    # Extract the features
    imageSize = shape(im)
    if im.ndim == 3:
        if imageSize[2] != 3:
            # "IndexError: tuple index out of range" if both if's are checked at the same time
            raise ValueError("Image data in unknown format/shape")
    if opts.color == 'gray':
        numChannels = 1
        if (im.ndim == 2):
            im = vl_rgb2gray(im)
    else:
        numChannels = 3
        if (im.ndim == 2):
            im = dstack([im, im, im])
        if opts.color == 'rgb':
            pass
        elif opts.color == 'opponent':
            # from https://github.com/vlfeat/vlfeat/blob/master/toolbox/sift/vl_phow.m
            # Note that the mean differs from the standard definition of opponent
            # space and is the regular intesity (for compatibility with
            # the contrast thresholding).
            # Note also that the mean is added pack to the other two
            # components with a small multipliers for monochromatic
            # regions.

            mu = 0.3 * im[:, :, 0] + 0.59 * im[:, :, 1] + 0.11 * im[:, :, 2]
            alpha = 0.01
            im = dstack([
                mu, (im[:, :, 0] - im[:, :, 1]) / sqrt(2) + alpha * mu,
                (im[:, :, 0] + im[:, :, 1] - 2 * im[:, :, 2]) / sqrt(6) +
                alpha * mu
            ])
        else:
            raise ValueError('Color option ' + str(opts.color) +
                             ' not recognized')
    if opts.verbose:
        print('{0}: color space: {1}'.format('vl_phow', opts.color))
        print('{0}: image size: {1} x {2}'.format('vl_phow', imageSize[0],
                                                  imageSize[1]))
        print('{0}: sizes: [{1}]'.format('vl_phow', opts.sizes))

    frames_all = []
    descrs_all = []
    for size_of_spatial_bins in opts.sizes:
        # from https://github.com/vlfeat/vlfeat/blob/master/toolbox/sift/vl_phow.m
        # Recall from VL_DSIFT() that the first descriptor for scale SIZE has
        # center located at XC = XMIN + 3/2 SIZE (the Y coordinate is
        # similar). It is convenient to align the descriptors at different
        # scales so that they have the same geometric centers. For the
        # maximum size we pick XMIN = 1 and we get centers starting from
        # XC = 1 + 3/2 MAX(OPTS.SIZES). For any other scale we pick XMIN so
        # that XMIN + 3/2 SIZE = 1 + 3/2 MAX(OPTS.SIZES).
        # In pracrice, the offset must be integer ('bounds'), so the
        # alignment works properly only if all OPTS.SZES are even or odd.

        off = floor(3.0 / 2 * (max(opts.sizes) - size_of_spatial_bins)) + 1

        # smooth the image to the appropriate scale based on the size
        # of the SIFT bins
        sigma = size_of_spatial_bins / float(opts.magnif)
        ims = vl_imsmooth(im, sigma)

        # extract dense SIFT features from all channels
        frames = []
        descrs = []
        for k in range(numChannels):
            size_of_spatial_bins = int(size_of_spatial_bins)
            # vl_dsift does not accept numpy.int64 or similar
            f_temp, d_temp = vl_dsift(data=ims[:, :, k],
                                      step=dsiftOpts.step,
                                      size=size_of_spatial_bins,
                                      fast=dsiftOpts.fast,
                                      verbose=dsiftOpts.verbose,
                                      norm=dsiftOpts.norm,
                                      bounds=[off, off, maxint, maxint])
            frames.append(f_temp)
            descrs.append(d_temp)
        frames = array(frames)
        descrs = array(descrs)
        d_new_shape = [descrs.shape[0] * descrs.shape[1], descrs.shape[2]]
        descrs = descrs.reshape(d_new_shape)
        # remove low contrast descriptors
        # note that for color descriptors the V component is
        # thresholded
        if (opts.color == 'gray') | (opts.color == 'opponent'):
            contrast = frames[0][2, :]
        elif opts.color == 'rgb':
            contrast = mean(
                [frames[0][2, :], frames[1][2, :], frames[2][2, :]], 0)
        else:
            raise ValueError('Color option ' + str(opts.color) +
                             ' not recognized')
        descrs[:, contrast < opts.contrastthreshold] = 0

        # save only x,y, and the scale
        frames_temp = array(frames[0][0:3, :])
        padding = array(size_of_spatial_bins * ones(frames[0][0].shape))
        frames_all.append(vstack([frames_temp, padding]))
        descrs_all.append(array(descrs))

    frames_all = hstack(frames_all)
    descrs_all = hstack(descrs_all)
    return frames_all, descrs_all
def process_image(imagename, resultname='temp.sift', dense=False):
    """ process an image and save the results in a .key ascii file"""
    print "working on ", imagename
    if dense == False:
        if imagename[-3:] != 'pgm':
            #create a pgm file, image is resized, if it is too big.
            # sift returns an error if more than 8000 features are found
            size = (MAXSIZE, MAXSIZE)
            im = Image.open(imagename).convert('L')
            im.thumbnail(size, Image.ANTIALIAS)
            im.save('tmp.pgm')
            imagename = 'tmp.pgm'

        #check if linux or windows
        if os.name == "posix":
            cmmd = "./sift <" + imagename + ">" + resultname
            print cmmd
        else:
            cmmd = "siftWin32 <" + imagename + ">" + resultname

        os.system(cmmd)
        if os.path.getsize(resultname) == 0:
            raise IOError("extracting SIFT features failed " + resultname)
        #print 'processed', imagename
    else:
        import vlfeat

        # like in pinto2008 why is vision hard
        size = (150, 150)
        window_size = 8
        step = 10

        im = Image.open(imagename).resize(size, Image.ANTIALIAS)
        im_array = numpy.asarray(im)
        if im_array.ndim == 3:
            im_gray = vlfeat.vl_rgb2gray(im_array)
        elif im_array.ndim == 2:
            im_gray = im_array
        else:
            raise IOError("Not enough dims found in image " + resultname)

        #locs,int_descriptors = vlfeat.vl_dsift(im_gray,size=window_size,verbose=VERBOSE)
        locs, int_descriptors = vlfeat.vl_dsift(im_gray,
                                                step=step,
                                                verbose=VERBOSE)
        nfeatures = int_descriptors.shape[1]
        padding = numpy.zeros((2, nfeatures))
        locs = numpy.vstack((locs, padding))
        header = ' '.join([str(nfeatures), str(128)])
        temp = int_descriptors.astype('float')  # convert descriptors to float
        descriptors = temp[:]
        with open(resultname, 'wb') as f:
            cPickle.dump([locs.T, descriptors.T],
                         f,
                         protocol=cPickle.HIGHEST_PROTOCOL)
        print "features saved in", resultname
        if WRITE_VERBOSE:
            with open(resultname, 'w') as f:
                f.write(header)
                f.write("\n")
                for i in range(nfeatures):
                    f.write(' '.join(map(str, locs[:, i])))
                    f.write("\n")
                    f.write(' '.join(map(str, descriptors[:, i])))
                    f.write("\n")
Esempio n. 5
0
def dsift(im,
            verbose=True,
            fast=True,
            sizes=[4, 6, 8, 10],
            step=2,
            color='rgb',
            floatdescriptors=False,
            magnif=6,
            windowsize=1.5,
            contrastthreshold=0.005):

    opts = Options(verbose, fast, sizes, step, color, floatdescriptors,
                   magnif, windowsize, contrastthreshold)
    dsiftOpts = DSiftOptions(opts)

    # make sure image is float, otherwise segfault
    im = array(im, 'float32')

    # Extract the features
    imageSize = shape(im)
    if im.ndim == 3:
        if imageSize[2] != 3:
            # "IndexError: tuple index out of range" if both if's are checked at the same time
            raise ValueError("Image data in unknown format/shape")
    if opts.color == 'gray':
        numChannels = 1
        if (im.ndim == 2):
            im = vl_rgb2gray(im)
    else:
        numChannels = 3
        if (im.ndim == 2):
            im = dstack([im, im, im])
        if opts.color == 'rgb':
            pass
        elif opts.color == 'opponent':
             # from https://github.com/vlfeat/vlfeat/blob/master/toolbox/sift/vl_phow.m
             # Note that the mean differs from the standard definition of opponent
             # space and is the regular intesity (for compatibility with
             # the contrast thresholding).
             # Note also that the mean is added pack to the other two
             # components with a small multipliers for monochromatic
             # regions.

            mu = 0.3 * im[:, :, 0] + 0.59 * im[:, :, 1] + 0.11 * im[:, :, 2]
            alpha = 0.01
            im = dstack([mu,
                         (im[:, :, 0] - im[:, :, 1]) / sqrt(2) + alpha * mu,
                         (im[:, :, 0] + im[:, :, 1] - 2 * im[:, :, 2]) / sqrt(6) + alpha * mu])
        else:
            raise ValueError('Color option ' + str(opts.color) + ' not recognized')
    if opts.verbose:
	great='great'
        #print('{0}: color space: {1}'.format('vl_phow', opts.color))
        #print('{0}: image size: {1} x {2}'.format('vl_phow', imageSize[0], imageSize[1]))
        #print('{0}: sizes: [{1}]'.format('vl_phow', opts.sizes))

    frames_all = []
    descrs_all = []
    for size_of_spatial_bins in opts.sizes:
        # from https://github.com/vlfeat/vlfeat/blob/master/toolbox/sift/vl_phow.m
        # Recall from VL_DSIFT() that the first descriptor for scale SIZE has
        # center located at XC = XMIN + 3/2 SIZE (the Y coordinate is
        # similar). It is convenient to align the descriptors at different
        # scales so that they have the same geometric centers. For the
        # maximum size we pick XMIN = 1 and we get centers starting from
        # XC = 1 + 3/2 MAX(OPTS.SIZES). For any other scale we pick XMIN so
        # that XMIN + 3/2 SIZE = 1 + 3/2 MAX(OPTS.SIZES).
        # In pracrice, the offset must be integer ('bounds'), so the
        # alignment works properly only if all OPTS.SZES are even or odd.

        off = floor(3.0 / 2 * (max(opts.sizes) - size_of_spatial_bins)) + 1

        # smooth the image to the appropriate scale based on the size
        # of the SIFT bins
        sigma = size_of_spatial_bins / float(opts.magnif)
        ims = vl_imsmooth(im, sigma)

        # extract dense SIFT features from all channels
        frames = []
        descrs = []
        for k in range(numChannels):
            size_of_spatial_bins = int(size_of_spatial_bins)
            # vl_dsift does not accept numpy.int64 or similar
            f_temp, d_temp = vl_dsift(data=ims[:, :, k],
                                      step=dsiftOpts.step,
                                      size=size_of_spatial_bins,
                                      fast=dsiftOpts.fast,
                                      verbose=dsiftOpts.verbose,
                                      norm=dsiftOpts.norm,
                                      bounds=[off, off, maxint, maxint])
            frames.append(f_temp)
            descrs.append(d_temp)
        frames = array(frames)
        descrs = array(descrs)
        d_new_shape = [descrs.shape[0] * descrs.shape[1], descrs.shape[2]]
        descrs = descrs.reshape(d_new_shape)
        # remove low contrast descriptors
        # note that for color descriptors the V component is
        # thresholded
        if (opts.color == 'gray') | (opts.color == 'opponent'):
            contrast = frames[0][2, :]
        elif opts.color == 'rgb':
            contrast = mean([frames[0][2, :], frames[1][2, :], frames[2][2, :]], 0)
        else:
            raise ValueError('Color option ' + str(opts.color) + ' not recognized')
        descrs[:, contrast < opts.contrastthreshold] = 0

        # save only x,y, and the scale
        frames_temp = array(frames[0][0:3, :])
        padding = array(size_of_spatial_bins * ones(frames[0][0].shape))
        frames_all.append(vstack([frames_temp, padding]))
        descrs_all.append(array(descrs))


    frames_all = hstack(frames_all)
    descrs_all = hstack(descrs_all)
    return frames_all, descrs_all
Esempio n. 6
0
import Image
import numpy
import pylab
import vlfeat
from vlfeat.plotop.vl_plotframe import vl_plotframe
from numpy.random import shuffle


if __name__ == '__main__':
	# VL_DEMO_SIFT_BASIC  Demo: SIFT: basic functionality
	
	# --------------------------------------------------------------------
	#                     Load a figure and convert the to required format
	# --------------------------------------------------------------------
	I = Image.open('../../../data/a.jpg')
	I = vlfeat.vl_rgb2gray(numpy.array(I))	
	I = numpy.array(I, 'f', order='F') # 'F' = column-major order!

	pylab.gray()
	pylab.imshow(I)	
	print 'sift_basic_1'
	
	# --------------------------------------------------------------------
	#                                                             Run SIFT
	# --------------------------------------------------------------------
	f, d = vlfeat.vl_sift(I)
	sel = numpy.arange(f.shape[1])	
	shuffle(sel)
	vl_plotframe(f[:, sel[:50]], color='k', linewidth=3)
	vl_plotframe(f[:, sel[:50]], color='y')
	
Esempio n. 7
0
def process_image(imagename, resultname='temp.sift', dense=False):    
    """ process an image and save the results in a .key ascii file"""
    #print "working on ", imagename
    if dense == False:
        if imagename[-3:] != 'pgm':
            #create a pgm file, image is resized, if it is too big.
            # sift returns an error if more than 8000 features are found
            size = (MAXSIZE, MAXSIZE)
            im = Image.open(imagename).convert('L')
            im.thumbnail(size, Image.ANTIALIAS)
            im.save('tmp.pgm')
            imagename = 'tmp.pgm'
        
        #check if linux or windows 
        if os.name == "posix":
            cmmd = "./sift < " + imagename + " > " + resultname
        else:
            cmmd = "siftWin32 < " + imagename + " > " + resultname
        
        # run extraction command
        returnvalue = subprocess.call(cmmd, shell=True)
        if returnvalue == 127:
            os.remove(resultname) # removing empty resultfile created by output redirection
            raise IOError("SIFT executable not found")
        if returnvalue == 2:
            os.remove(resultname) # removing empty resultfile created by output redirection
            raise IOError("image " + imagename + " not found")            
        if os.path.getsize(resultname) == 0:
            raise IOError("extracting SIFT features failed " + resultname)

    else:
        import vlfeat

        # defines how dense the grid is
        size = (150, 150)
        step = 10
        
        im = Image.open(imagename).resize(size, Image.ANTIALIAS)
        im_array = numpy.asarray(im)
        if im_array.ndim == 3:
            im_gray = vlfeat.vl_rgb2gray(im_array)
        elif im_array.ndim == 2:
            im_gray = im_array
        else:
            raise IOError("Not enough dims found in image " + resultname)
        

        locs, int_descriptors = vlfeat.vl_dsift(im_gray, step=step, verbose=VERBOSE)
        nfeatures = int_descriptors.shape[1]
        padding = numpy.zeros((2, nfeatures))
        locs = numpy.vstack((locs, padding))
        header = ' '.join([str(nfeatures), str(128)])
        temp = int_descriptors.astype('float')  # convert descriptors to float
        descriptors = temp[:]
        with open(resultname, 'wb') as f:
            cPickle.dump([locs.T, descriptors.T], f, protocol=cPickle.HIGHEST_PROTOCOL)
        print "features saved in", resultname
        if WRITE_VERBOSE:
            with open(resultname, 'w') as f:
                f.write(header)
                f.write("\n")
                for i in range(nfeatures):
                    f.write(' '.join(map(str, locs[:, i])))
                    f.write("\n")
                    f.write(' '.join(map(str, descriptors[:, i])))
                    f.write("\n")
def process_image(imagename, resultname="temp.sift", dense=False):
    """ process an image and save the results in a .key ascii file"""
    print "working on ", imagename
    if dense == False:
        if imagename[-3:] != "pgm":
            # create a pgm file, image is resized, if it is too big.
            # sift returns an error if more than 8000 features are found
            size = (MAXSIZE, MAXSIZE)
            im = Image.open(imagename).convert("L")
            im.thumbnail(size, Image.ANTIALIAS)
            im.save("tmp.pgm")
            imagename = "tmp.pgm"

        # check if linux or windows
        if os.name == "posix":
            cmmd = "./sift < " + imagename + " > " + resultname
        else:
            cmmd = "siftWin32 < " + imagename + " > " + resultname

        # run extraction command
        returnvalue = subprocess.call(cmmd, shell=True)
        if returnvalue == 127:
            os.remove(resultname)  # removing empty resultfile created by output redirection
            raise IOError("SIFT executable not found")
        if returnvalue == 2:
            os.remove(resultname)  # removing empty resultfile created by output redirection
            raise IOError("image " + imagename + " not found")
        if os.path.getsize(resultname) == 0:
            raise IOError("extracting SIFT features failed " + resultname)

    else:
        import vlfeat

        # defines how dense the grid is
        size = (150, 150)
        step = 10

        im = Image.open(imagename).resize(size, Image.ANTIALIAS)
        im_array = numpy.asarray(im)
        if im_array.ndim == 3:
            im_gray = vlfeat.vl_rgb2gray(im_array)
        elif im_array.ndim == 2:
            im_gray = im_array
        else:
            raise IOError("Not enough dims found in image " + resultname)

        locs, int_descriptors = vlfeat.vl_dsift(im_gray, step=step, verbose=VERBOSE)
        nfeatures = int_descriptors.shape[1]
        padding = numpy.zeros((2, nfeatures))
        locs = numpy.vstack((locs, padding))
        header = " ".join([str(nfeatures), str(128)])
        temp = int_descriptors.astype("float")  # convert descriptors to float
        descriptors = temp[:]
        with open(resultname, "wb") as f:
            cPickle.dump([locs.T, descriptors.T], f, protocol=cPickle.HIGHEST_PROTOCOL)
        print "features saved in", resultname
        if WRITE_VERBOSE:
            with open(resultname, "w") as f:
                f.write(header)
                f.write("\n")
                for i in range(nfeatures):
                    f.write(" ".join(map(str, locs[:, i])))
                    f.write("\n")
                    f.write(" ".join(map(str, descriptors[:, i])))
                    f.write("\n")