Esempio n. 1
0
def countRegions():
    # Requires: -the first command line argument is the name of the
    #            image to be segmented
    #           -the second command line argument is the color space being
    #            used, either RGB, HSV, or HLS
    # Effects: -calls closure with count foreground argument on, returns
    #           count of distinct foreground objects
    
    colorSpace = argv[2].lower()
    
    if not (colorSpace in ["rgb", "hsv", "hls"]):
        print "Second argument not one of RGB, HSV, or HLS"
        print "The first argument should be the name of the image to be segmented"
        print "Followed by the desire color space representation"
        exit(1)
    
    try:
        image = Image.open(argv[1])
        imageData = colorSpaceConvert(list(image.getdata()), argv[2].lower())
    except:
        print "Invalid or no image name given"
        print "The first argument should be the name of the image to be segmented"
        print "Followed by the desire color space representation"
        exit(1)
        
    if colorSpace == "rgb":
        redMinMax = raw_input("Red min-max, between 0 and 255: ")
        greenMinMax = raw_input("Green min-max, between 0 and 255: ")
        blueMinMax = raw_input("Blue min-max, between 0 and 255: ")
        redMinMax = [float(x) / 255.0 for x in redMinMax.split()]
        greenMinMax = [float(x) / 255.0 for x in greenMinMax.split()]
        blueMinMax = [float(x) / 255.0 for x in blueMinMax.split()]
        colorRanges = [redMinMax, greenMinMax, blueMinMax]
    elif colorSpace == "hsv":
        hueMinMax = raw_input("Hue min-max, between 0 and 360: ")
        satMinMax = raw_input("Saturation min-max, between 0 and 100: ")
        valMinMax = raw_input("Value min-max, between 0 and 100: ")
        hueMinMax = [float(x) / 360.0 for x in hueMinMax.split()]
        satMinMax = [float(x) / 100.0 for x in satMinMax.split()]
        valMinMax = [float(x) / 100.0 for x in valMinMax.split()]
        colorRanges = [hueMinMax, satMinMax, valMinMax]
    else:
        hueMinMax = raw_input("Hue min-max, between 0 and 360: ")
        lightMinMax = raw_input("Lightness min-max, between 0 and 100: ")
        satMinMax = raw_input("Saturation min-max, between 0 and 100: ")
        hueMinMax = [float(x) / 360.0 for x in hueMinMax.split()]
        lightMinMax = [float(x) / 100.0 for x in lightMinMax.split()]
        satMinMax = [float(x) / 100.0 for x in satMinMax.split()]
        colorRanges = [hueMinMax, lightMinMax, satMinMax]
    
    param = Parameters()
    param.setImageSize(image.size)
    param.setColorRanges(colorRanges)
    
    seg = segmentation.colorSegmenter()
    mask = seg.segmentImage(imageData, param, True)
    
    close = closure.closure()
    close.segmentRegions(mask, param, 0, True, False)
Esempio n. 2
0
def predict(folderName,
            parameters,
            segmentAlgo,
            fitnessFunc,
            plot=False,
            exportImages=False):
    # Requires: -parameters is of type Parameters
    #           -segmentAlgo is of type Segment
    #           -fitnessFunc is of type Fitness
    #           -folder is a string of a folder which contains two subfolders:
    #               -original which contains the original image
    #               -manualsegmentations which contains segmentations
    #                of the original images, the segmentations have the same
    #                name and are of .png format
    #           -plot and export is of type Bool
    # Effects: -attempts to segment images inside of the speicied folder
    #           based on the single sample image / mask provided to the system
    #          -outputs a histogram plot, "plot-date-time.png", of the fitness
    #           distrubution of the images segmented if plot = True
    #          -saves masks of the segmented images if export = True
    file_list = glob.glob(folderName + "original/" + "*")

    prefixLen = len(folderName) + len("original/")
    suffixLen = len(file_list[0].split(".")[-1]) + 1

    fitnessList = []

    iteration = 1
    for fileName in file_list:
        image = Image.open(fileName)
        if parameters.colorSpace in ("hsv", "hls"):
            imageData = colorSpaceConvert(list(image.getdata()),
                                          parameters.colorSpace)
        else:
            imageData = colorSpaceConvert(list(image.getdata()),
                                          parameters.colorSpace)

        maskname = fileName[prefixLen:-suffixLen] + ".png"
        mask = Image.open(folderName + "manualsegmentations/" + maskname)
        idealMaskData = list(mask.getdata())

        parameters.setImageSize(image.size)

        maskData = segmentAlgo.segmentImage(imageData, parameters, True)
        fit = fitnessFunc.findFitness(maskData, idealMaskData, parameters)

        # save mask if export enabled
        if exportImages == True:
            dataToImage(maskData, image.size, "-" + str(iteration))

        fitnessList.append(fit / float(image.size[0] * image.size[1]))
        iteration += 1

    time = datetime.datetime.now()

    npFitnessList = numpy.array(fitnessList)
    mu = npFitnessList.mean()
    median = numpy.median(npFitnessList)
    sigma = npFitnessList.std()
    textstr = '$\overline{x}=%.2f$\n$\mathrm{median}=%.2f$\n$\sigma=%.2f$' % (
        mu, median, sigma)

    fig, ax = pylab.subplots(1)

    pylab.hist(fitnessList, bins=10)
    pylab.xlabel('Fitness ratio (Fitness / Image Size)')
    pylab.ylabel('Number of Images')
    pylab.title('Number of Images vs. Fitness Ratio')

    props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)

    pylab.text(0.78,
               0.95,
               textstr,
               transform=ax.transAxes,
               fontsize=14,
               verticalalignment='top',
               bbox=props)

    timeString = "output-" + str(time.month) + '.' + str(time.day) + '.' + str(
        time.year)
    timeString += '-' + str(time.hour) + '.' + str(time.minute)

    pylab.savefig("plotImages" + timeString + ".png")
Esempio n. 3
0
def main():
    # commented out try for debugging purposes
    #try:
        shortOpts = "d:f:s:i:m:hepc:r:"
        longOpts = ["segment=", "fitness=", "search=", "image=", 
                    "mask=", "help", "export", "plot", "close=", "predict="]
        
        try:
            options, remainder = getopt.getopt(sys.argv[1:], shortOpts, longOpts)
        except:
            print "\nERROR: Invalid option argument\n"
            exit(1)
        
        export = False
        plot = False
        close = False
        predictImages = False
        
        # sets relevant variables based on command line input
        for opt, arg in options:
            if opt in ("-d", "--segment"):
                segmenterName = arg
            elif opt in ("-f", "--fitness"):
                fitnessName = arg
            elif opt in ("-s", "--search"):
                searchName = arg
            elif opt in ("-i", "--image"):
                imageName = arg
            elif opt in ("-m", "--mask"):
                idealMaskName = arg
            elif opt in ("-e", "--export"):
                export = True
            elif opt in ("-p", "--plot"):
                plot = True
            elif opt in ("-c", "--close"):
                close = True
                closeType = arg
            elif opt in ("-r", "--predict"):
                predictImages = True
                predictFolderName = arg
            elif opt in ("-h", "--help"):
                print __doc__
                exit(0)
            else:
                pass
        
        # quit if extraneous input provided       
        if remainder != []:
            print "\nERROR: Extraneous input\n"
            exit(1)
            
        # initialize segmenter algorithm
        if segmenterName.lower() in ("rgb", "hsv", "hls"):
            segmenter = segmentation.colorSegmenter()
        else:
            print "\nERROR: Invalid or no segmenter name\n"
            exit(1)
        
        # initialize fitness function
        if fitnessName.lower() == "diff":
            fitnessFunc = fitness.absDiffFitness()
        else:
            print "\nERROR: Invalid or no fitness name\n"
            exit(1)
        
        # initialize search space algorithm
        if searchName.lower() == "random":
            searchFunc = RandomSearch.randomSearch(segmenter, fitnessFunc)
        elif searchName.lower() == "genetic":
            searchFunc = GeneticSearch.geneticSearch(segmenter, fitnessFunc)
        elif searchName.lower() == "anneal":
            searchFunc = AnnealSearch.annealSearch(segmenter, fitnessFunc)
        else:
            print "\nERROR: Invalid or no search name\n"
            exit(1)
        
        # try to open image, and convert image data from a [0, 255] RGB space 
        # to a [0, 1] normalized RGB, HSV, or HLS space, depending on the segmenter selected
        # (chooses HSV or HLS if their respective segmenter is selected, else selects RGB)
        # if opening image fails, quit with error
        try:
            image = Image.open(imageName)
            
            # initialize parameters object, init's image size and color space used
            parameter = parameters.Parameters()
            parameter.setImageSize(image.size)
        
            # use hsv or hls if segmenter specified, else use rgb by default
            if segmenterName.lower() in ("hsv", "hls"):
                parameter.setColorSpace(segmenterName.lower())
            else:
                parameter.setColorSpace("rgb")
            
            imageData = colorSpaceConvert(list(image.getdata()), parameter.colorSpace)
                
        except:
            print "\nERROR: Invalid or no image name\n"
            exit(1)
            
        # try to open ideal mask, if it fails, quit with error
        try:
            mask = Image.open(idealMaskName)
            idealMaskData = list(mask.getdata())
        except:
            print "\nERROR: Invalid or no mask name\n"
            exit(1)
        
        # run search on image parameter space for segmentation
        # returns optimal paramaters found upon search completion
        # and saves a plot of fitness vs. search extent if plot set to true
        optimalParameters = searchFunc.searchImage(imageData, idealMaskData, parameter, plot)
        
        # reset upper limit
        optimalParameters.setUpperLimit(float("inf"))
        
        # if export enabled, saves mask using optimal parameters found to output.png
        if (export == True):
            segmenter.segmentImage(imageData, optimalParameters, True)
        
        # if export enabled, saves a 'closed' mask using optimal parameters found to output.png
        if (close == True):
            whiteArg = 1 if closeType.lower() == "white" else 0
            mask = segmenter.segmentImage(imageData, optimalParameters)
            close = closure.closure()
            close.segmentRegions(mask, optimalParameters, saveImage = export, clearWhite = whiteArg)
        

        if predictImages == True:
            predict.predict(predictFolderName, optimalParameters, segmenter, fitnessFunc,
                           plot = True, exportImages = export) 
Esempio n. 4
0
def predict(folderName, parameters, segmentAlgo,
            fitnessFunc, plot = False, exportImages = False):
    # Requires: -parameters is of type Parameters
    #           -segmentAlgo is of type Segment
    #           -fitnessFunc is of type Fitness
    #           -folder is a string of a folder which contains two subfolders:
    #               -original which contains the original image
    #               -manualsegmentations which contains segmentations
    #                of the original images, the segmentations have the same
    #                name and are of .png format
    #           -plot and export is of type Bool
    # Effects: -attempts to segment images inside of the speicied folder
    #           based on the single sample image / mask provided to the system
    #          -outputs a histogram plot, "plot-date-time.png", of the fitness
    #           distrubution of the images segmented if plot = True
    #          -saves masks of the segmented images if export = True
    file_list = glob.glob(folderName + "original/" + "*")
    
    prefixLen = len(folderName) + len("original/")
    suffixLen = len(file_list[0].split(".")[-1]) + 1
    
    fitnessList = []
    
    iteration = 1
    for fileName in file_list:
        image = Image.open(fileName)
        if parameters.colorSpace in ("hsv", "hls"):
            imageData = colorSpaceConvert(list(image.getdata()), parameters.colorSpace)
        else:
            imageData = colorSpaceConvert(list(image.getdata()), parameters.colorSpace)
            
        
        maskname = fileName[prefixLen:-suffixLen] + ".png"
        mask = Image.open(folderName + "manualsegmentations/" + maskname)
        idealMaskData = list(mask.getdata())
        
        parameters.setImageSize(image.size)
        
        maskData = segmentAlgo.segmentImage(imageData, parameters, True)
        fit = fitnessFunc.findFitness(maskData, idealMaskData, parameters)
        
        # save mask if export enabled
        if exportImages == True:
            dataToImage(maskData, image.size, "-" + str(iteration))
        
        fitnessList.append(fit / float(image.size[0] * image.size[1]))
        iteration += 1
    
    time = datetime.datetime.now()
    
    npFitnessList = numpy.array(fitnessList)
    mu = npFitnessList.mean()
    median = numpy.median(npFitnessList)
    sigma = npFitnessList.std()
    textstr = '$\overline{x}=%.2f$\n$\mathrm{median}=%.2f$\n$\sigma=%.2f$'%(mu, median, sigma)
    
    fig, ax = pylab.subplots(1)
    
    pylab.hist(fitnessList, bins = 10)
    pylab.xlabel('Fitness ratio (Fitness / Image Size)')
    pylab.ylabel('Number of Images')
    pylab.title('Number of Images vs. Fitness Ratio')
    
    props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
    
    pylab.text(0.78, 0.95, textstr, transform=ax.transAxes, fontsize=14,
        verticalalignment='top', bbox=props)
    
    timeString = "output-" + str(time.month) + '.' + str(time.day) + '.' + str(time.year) 
    timeString += '-' + str(time.hour) + '.' + str(time.minute)  
     
    pylab.savefig("plotImages" + timeString + ".png")