示例#1
0
 def normalise(self, i_ipl_image):
     #Do the affine transform
     if self.__rot_mat == None:
         warped_image = i_ipl_image
     else:
         warped_image = cv.cvCreateImage(
             cv.cvSize(i_ipl_image.width, i_ipl_image.height), 8, 1)
         cv.cvWarpAffine(i_ipl_image, warped_image, self.__rot_mat)
     #Crop
     if self.__roi == None:
         self.__cropped_image = warped_image
     else:
         self.crop(warped_image)
     #Scale
     if self.__resize_scale == 1:
         scaled_image = self.__cropped_image
     else:
         w = int(round(self.__cropped_image.width * self.__resize_scale))
         h = int(round(self.__cropped_image.height * self.__resize_scale))
         scaled_image = cv.cvCreateImage(cv.cvSize(w, h), 8, 1)
         cv.cvResize(self.__cropped_image, scaled_image, cv.CV_INTER_LINEAR)
     #Histogram equalisation
     if self.__equalise_hist:
         cv.cvEqualizeHist(scaled_image, scaled_image)
     #Blur
     if self.__filter_size == 0:
         smoothed_image = scaled_image
     else:
         smoothed_image = cv.cvCreateImage(
             cv.cvSize(scaled_image.width, scaled_image.height), 8, 1)
         cv.cvSmooth(scaled_image, smoothed_image, cv.CV_GAUSSIAN,
                     self.__filter_size)
     return smoothed_image
示例#2
0
    def findFaces(self, img):
        faces = []

        self.detect_time = time.time()
        rects = self.face_detector.detect(img)
        self.detect_time = time.time() - self.detect_time

        cvtile = opencv.cvCreateMat(128, 128, opencv.CV_8UC3)
        bwtile = opencv.cvCreateMat(128, 128, opencv.CV_8U)

        cvimg = img.asOpenCV()

        self.eye_time = time.time()

        for rect in rects:
            faceim = opencv.cvGetSubRect(cvimg, rect.asOpenCV())
            opencv.cvResize(faceim, cvtile)

            affine = pv.AffineFromRect(rect, (128, 128))

            opencv.cvCvtColor(cvtile, bwtile, cv.CV_BGR2GRAY)

            leye, reye, lcp, rcp = self.fel.locateEyes(bwtile)
            leye = pv.Point(leye)
            reye = pv.Point(reye)

            leye = affine.invertPoint(leye)
            reye = affine.invertPoint(reye)

            faces.append([rect, leye, reye])

        self.eye_time = time.time() - self.eye_time
        self.current_faces = faces

        return faces
示例#3
0
 def normalise(self, i_ipl_image):
     #Do the affine transform
     if self.__rot_mat == None:
         warped_image = i_ipl_image
     else:
         warped_image = cv.cvCreateImage(cv.cvSize(i_ipl_image.width,i_ipl_image.height), 8, 1)
         cv.cvWarpAffine(i_ipl_image , warped_image,  self.__rot_mat );
     #Crop
     if self.__roi == None:
         self.__cropped_image = warped_image
     else:
         self.crop(warped_image)
     #Scale
     if  self.__resize_scale == 1:
         scaled_image = self.__cropped_image
     else: 
         w = int(round( self.__cropped_image.width * self.__resize_scale))
         h = int(round( self.__cropped_image.height * self.__resize_scale))
         scaled_image = cv.cvCreateImage(cv.cvSize(w, h), 8, 1)
         cv.cvResize( self.__cropped_image, scaled_image ,cv.CV_INTER_LINEAR)
     #Histogram equalisation
     if self.__equalise_hist: 
         cv.cvEqualizeHist(scaled_image,scaled_image)
     #Blur
     if self.__filter_size == 0: 
         smoothed_image = scaled_image
     else: 
         smoothed_image = cv.cvCreateImage(cv.cvSize(scaled_image.width, scaled_image.height), 8, 1)
         cv.cvSmooth(scaled_image, smoothed_image, cv.CV_GAUSSIAN, self.__filter_size)
     return smoothed_image
def drawImage(image,h,w,psize):
    """
    Draw the image as a continuous line on a surface h by w "pixels" where 
    each continuous line representation of a pixel in image is represented
    on the output suface using psize by psize "pixels".

    @param  image   an opencv image with at least 3 channels
    @param  h       integer representing the hight of the output surface
    @param  w       integer representing the width of the output surface
    @param  psize   ammount that each pixel in the input image is scaled up
    """
    h = (h/psize)-2
    w = (w/psize)-2
    size = opencv.cvSize(w,h)
    scaled = opencv.cvCreateImage(size,8,3)
    red = opencv.cvCreateImage(size,8,1)
    blue = opencv.cvCreateImage(size,8,1)
    green = opencv.cvCreateImage(size,8,1)
    opencv.cvSplit(scaled,blue,green,red,None)
    opencv.cvEqualizeHist(red,red)
    opencv.cvEqualizeHist(green,green)
    opencv.cvEqualizeHist(blue,blue)
    opencv.cvMerge(red,green,blue,None,scaled)
    opencv.cvResize(image,scaled,opencv.CV_INTER_LINEAR)
    opencv.cvNot(scaled,scaled)

    # Draw each pixel in the image
    xr = range(scaled.width)
    whitespace = 0
    for y in range(scaled.height):
        for x in xr:
            s = opencv.cvGet2D(scaled,y,x)
            s = [s[j] for j in range(3)]
            if (sum(s)/710.0 < 1.0/psize):
                whitespace = whitespace+psize
            else:
                if whitespace is not 0:
                    line(whitespace,6,(xr[0]>0))
                    whitespace = 0
                drawPixel([j/255.0 for j in s],psize,(xr[0]>0))
        if whitespace is not 0:
            line(whitespace,6,(xr[0]>0))
            whitespace = 0
        line(psize,2)
        xr.reverse()
        displayImage(output)
        events = pygame.event.get()
        for event in events:
            if event.type == QUIT:
		exit()
示例#5
0
def get_image():
    im = highgui.cvQueryFrame(camera)

    # Add the line below if you need it (Ubuntu 8.04+)
    im = opencv.cvGetMat(im)

    # Resize image if needed
    resized_im = opencv.cvCreateImage(opencv.cvSize(XSCALE, YSCALE), 8, 3)
    opencv.cvResize(im, resized_im, opencv.CV_INTER_CUBIC)

    #convert Ipl image to PIL image
    pil_img = opencv.adaptors.Ipl2PIL(resized_im)

    enhancer = ImageEnhance.Brightness(pil_img)
    pil_img = enhancer.enhance(BRIGHTNESS)
    pil_img = ImageOps.mirror(pil_img)

    return pil_img
示例#6
0
def get_image():
    im = highgui.cvQueryFrame(camera)

# Add the line below if you need it (Ubuntu 8.04+)
    im = opencv.cvGetMat(im)


# Resize image if needed
    resized_im=opencv.cvCreateImage(opencv.cvSize(XSCALE,YSCALE),8,3)
    opencv.cvResize( im, resized_im, opencv.CV_INTER_CUBIC);

#convert Ipl image to PIL image
    pil_img = opencv.adaptors.Ipl2PIL(resized_im)

    enhancer=ImageEnhance.Brightness(pil_img)
    pil_img=enhancer.enhance(BRIGHTNESS)
    pil_img=ImageOps.mirror(pil_img)

    return pil_img
示例#7
0
def scale_image(img, scale):
    new_img = cv.cvCreateImage(
        cv.cvSize(img.width * scale, img.height * scale), img.depth,
        img.nChannels)
    cv.cvResize(img, new_img, cv.CV_INTER_NN)
    return new_img
示例#8
0
def scale(image, s):
    scaled = cv.cvCreateImage(
        cv.cvSize(int(image.width * s), int(image.height * s)), image.depth,
        image.nChannels)
    cv.cvResize(image, scaled, cv.CV_INTER_AREA)
    return scaled
示例#9
0
    def compute(self, i_data, i_ipl=False):
        frame = 0
        self.__frame = -1
        max_dist = 0
        
        if i_ipl:
            nframes = len(i_data)
        else:
            nframes = i_data.shape[2]
        list_of_roi = []
        list_of_frames = []
        list_of_sizes = []
        
        for frame in range(0, nframes):
            if i_ipl:
                ipl_image = i_data[frame]
            else:
                ipl_image = cv.NumPy2Ipl(i_data[:,:,frame])
                
            if self.__scale < 1.0:
                w = numpy.int(numpy.round( float( ipl_image.width ) * self.__scale ))
                h = numpy.int(numpy.round( float( ipl_image.height ) * self.__scale ))
                small_image = cv.cvCreateImage( cv.cvSize( w, h  ) , ipl_image.depth, ipl_image.nChannels )
                cv.cvResize( ipl_image , small_image )
                vj_box = viola_jones_opencv(small_image)
            else:
                vj_box = viola_jones_opencv(ipl_image)

            if vj_box is not None:
                (min_row, min_col, max_row, max_col) = vj_box
                w = max_col - min_col
                h = max_row - min_row
                dist = w*w + h*h       
                list_of_roi.append(vj_box)
                list_of_frames.append(frame)
                list_of_sizes.append(dist)
                self.__n_rows = ipl_image.height 
                self.__n_cols = ipl_image.width
        #Choose a percentile of the sorted list
        nboxes = len(list_of_sizes)
        if nboxes == 0:
            #print "Viola-Jones failed on all images"
            return
        list_of_sizes = numpy.array(list_of_sizes)
        idx = numpy.argsort(list_of_sizes)
        percentile = 0.8
        arg_idx = numpy.int(numpy.round(percentile * nboxes))
        if arg_idx >= nboxes:
            arg_idx = nboxes - 1
        if arg_idx < 0:
            arg_idx = 0
            
        #print "n boxes: ", nboxes, " chosen arg: ", arg_idx
        self.__frame = frame  = list_of_frames[idx[arg_idx]]
        best_roi =  list_of_roi[idx[arg_idx]]
        (min_row, min_col, max_row, max_col) = best_roi
        if self.__scale < 1.0:
            #print "best roi width = ", max_col - min_col, " best roi height = ", max_row-min_row
            max_col  =  numpy.int(numpy.round( float(max_col) / self.__scale ))
            max_row  =  numpy.int(numpy.round( float(max_row) / self.__scale ))
            min_col  =  numpy.int(numpy.round( float(min_col) / self.__scale ))
            min_row  =  numpy.int(numpy.round( float(min_row) / self.__scale ))
        vj_box = (min_row, min_col, max_row, max_col)  
        self.setRoi(vj_box)
        return self.getRoi()
示例#10
0
def IplResize(i_image, i_width, i_height):
    """Convert RGB to Gray scale and resize to input width and height"""
    small_image = cv.cvCreateImage( cv.cvSize( i_width, i_height  ) , i_image.depth,  i_image.nChannels )
    cv.cvResize( i_image , small_image )
    return small_image
示例#11
0
def scale(image, s):
    scaled = cv.cvCreateImage(cv.cvSize(int(image.width * s), int(image.height * s)), image.depth, image.nChannels)
    cv.cvResize(image, scaled, cv.CV_INTER_AREA)
    return scaled
示例#12
0
def scale_image(img, scale):
    new_img = cv.cvCreateImage(cv.cvSize(img.width*scale, img.height*scale), 
            img.depth, img.nChannels)
    cv.cvResize(img, new_img, cv.CV_INTER_NN)
    return new_img
示例#13
0
def IplResize(i_image, i_width, i_height):
    """Convert RGB to Gray scale and resize to input width and height"""
    small_image = cv.cvCreateImage(cv.cvSize(i_width, i_height), i_image.depth,
                                   i_image.nChannels)
    cv.cvResize(i_image, small_image)
    return small_image