Exemplo n.º 1
0
def buildPatchFromScan(
    wrongPixelCenters,
    folderStore,
    scanName,
    scanPath,
    multispectralImagePath,
    panchromaticImagePath,
    actualPixelPointMachine,
    classifierInformation,
    isTest=False,
):
    # Show feedback
    if not isTest:
        print "Saving patch..."
    # Initialize
    multispectralImage = image_store.load(multispectralImagePath)
    panchromaticImage = image_store.load(panchromaticImagePath)
    windowLengthInMeters = classifierInformation.getWindowLengthInMeters()
    patchTestFraction = (
        classifierInformation.getTestDataset().countSamples()
        / float(classifierInformation.getTrainingDataset().countSamples())
        if not isTest
        else 0.2
    )
    # Set path
    targetPatchPath = folderStore.fillPatchPath(scanName + " auto")
    targetPatchFolderPath = os.path.dirname(targetPatchPath)
    # Define shortcut
    buildPatchEasily = lambda makePath, pixelCenters: buildPatch(
        makePath(targetPatchFolderPath),
        pixelCenters,
        actualPixelPointMachine,
        multispectralImage,
        panchromaticImage,
        windowLengthInMeters,
    )
    # Shuffle
    random.shuffle(wrongPixelCenters)
    # Prepare
    information = {
        "patches": {"probability name": scanName, "probability path": scanPath},
        "windows": {
            "window length in meters": windowLengthInMeters,
            "spatial reference": multispectralImage.getSpatialReference(),
        },
    }
    if not isTest:
        # Split
        patchTestCount = int(patchTestFraction * len(wrongPixelCenters))
        # Build
        information["training set"] = buildPatchEasily(
            sample_process.makeTrainingPath, wrongPixelCenters[patchTestCount:]
        ).getStatistics()
        information["test set"] = buildPatchEasily(
            sample_process.makeTestPath, wrongPixelCenters[:patchTestCount]
        ).getStatistics()
    # Save
    store.saveInformation(targetPatchPath, information)
 def extractSamples(self, positiveLocationPath, multispectralImagePath, panchromaticImagePath):
     view.sendFeedback('Loading images...\n\tmultispectralImagePath = %s\n\tpanchromaticImagePath = %s' % (multispectralImagePath, panchromaticImagePath))
     multispectralImage = image_store.load(multispectralImagePath)
     panchromaticImage = image_store.load(panchromaticImagePath)
     view.sendFeedback('Generating geoCenters...\n\tmultispectralPixelShiftValue = %s\n\tshiftCount = %s\n\tnegativeRatio = %s' % (self.multispectralPixelShiftValue, self.shiftCount, self.negativeRatio))
     positiveMultispectralPixelCenters = self.loadPixelCenters(multispectralImage, positiveLocationPath)
     negativeMultispectralPixelCenters = self.makePixelCenters(multispectralImage, positiveMultispectralPixelCenters)
     positiveGeoCenters = multispectralImage.convertPixelLocationsToGeoLocations(positiveMultispectralPixelCenters)
     negativeGeoCenters = multispectralImage.convertPixelLocationsToGeoLocations(negativeMultispectralPixelCenters)
     view.sendFeedback('Extracting positive samples...')
     self.extract(1, positiveGeoCenters, multispectralImage, panchromaticImage)
     view.sendFeedback('Extracting negative samples...')
     self.extract(0, negativeGeoCenters, multispectralImage, panchromaticImage)
def extractDataset(targetDatasetPath, paths, parameters):
    # Unpack
    multispectralImagePath, panchromaticImagePath, positiveLocationPath = paths
    windowGeoLength, negativeRatio, multispectralPixelShiftValue, shiftCount = parameters
    # Show feedback
    view.sendFeedback('Extracting dataset...\n\ttargetDatasetPath = %s' % targetDatasetPath)
    # Extract samples
    extractor = Extractor(targetDatasetPath, windowGeoLength, multispectralPixelShiftValue, shiftCount, negativeRatio)
    extractor.extractSamples(positiveLocationPath, multispectralImagePath, panchromaticImagePath)
    # Record
    targetDataset = extractor.getSampleDatabase()
    multispectralImage = image_store.load(multispectralImagePath)
    panchromaticImage = image_store.load(panchromaticImagePath)
    points, spatialReference = point_store.load(positiveLocationPath)
    store.saveInformation(targetDatasetPath, {
        'multispectral image': {
            'path': multispectralImagePath,
            'pixel width': multispectralImage.getPixelWidth(),
            'pixel height': multispectralImage.getPixelHeight(),
            'geo transform': multispectralImage.getGeoTransform(),
        },
        'panchromatic image': {
            'path': panchromaticImagePath,
            'pixel width': panchromaticImage.getPixelWidth(),
            'pixel height': panchromaticImage.getPixelHeight(),
            'geo transform': panchromaticImage.getGeoTransform(),
        },
        'positive location': {
            'path': positiveLocationPath,
            'location count': len(points),
            'spatial reference': spatialReference,
        },
        'windows': {
            'path': targetDatasetPath,
            'sample count': targetDataset.countSamples(),
            'positive sample count': targetDataset.countPositiveSamples(),
            'negative sample count': targetDataset.countNegativeSamples(),
        },
        'parameters': {
            'window geo length': windowGeoLength,
            'multispectral pixel shift value': multispectralPixelShiftValue,
            'shift count': shiftCount,
            'negative ratio': negativeRatio,
        }
    })
    # Return
    return targetDataset
def scan(targetProbabilityPath, classifierPath, multispectralImagePath, panchromaticImagePath, scanRatio, regionFrames=None):
    # Initialize
    classify = load(classifierPath)
    classifierInformation = Information(classifierPath)
    windowLengthInMeters = classifierInformation.getWindowLengthInMeters()
    multispectralImage = image_store.load(multispectralImagePath)
    panchromaticImage = image_store.load(panchromaticImagePath)
    # If no regions are defined,
    if not regionFrames: 
        # Use the entire image
        regionFrames = [(0, 0, multispectralImage.width, multispectralImage.height)]
    # Open probabilityFile
    probabilityFile = open(targetProbabilityPath, 'wt')
    # For each window,
    for regionIndex, regionFrame in enumerate(regionFrames):
        print 'Scanning region %s/%s...' % (regionIndex + 1, len(regionFrames))
        for window in image_process.makeWindowGenerator(multispectralImage, panchromaticImage, windowLengthInMeters, scanRatio, regionFrame):
            # Classify
            classification_string = '%s %s' % classify(imageContent=window.extractImage())
            windowLocation_string = '%s %s' % window.multispectralWindowLocation
            probabilityFile.write('%s %s\n' % (windowLocation_string, classification_string))
    # Close probabilityFile
    probabilityFile.close()
def evaluateWindows(probabilityPath, actualLocationPath, multispectralImagePath, windowGeoLength):
    # Initialize
    print 'Evaluating windows...'
    multispectralImage = image_store.load(multispectralImagePath)
    # Load
    probabilityPacks = probability_store.load(probabilityPath)
    windowLocations = [(x[0], x[1]) for x in probabilityPacks]
    windowPixelWidth, windowPixelHeight = multispectralImage.convertGeoDimensionsToPixelDimensions(windowGeoLength, windowGeoLength)
    windowCount = len(windowLocations)
    # Load predicted
    predictedWindowLocations = set((x[0], x[1]) for x in probabilityPacks if x[2] == 1)
    # Load actual
    actualGeoLocations = point_store.load(actualLocationPath)[0]
    actualPixelLocations = multispectralImage.convertGeoLocationsToPixelLocations(actualGeoLocations)
    actualPixelPointMachine = point_process.PointMachine(actualPixelLocations, 'INTEGER', windowPixelWidth, windowPixelHeight)
    actualWindowLocations = set(filter(lambda x: actualPixelPointMachine.getPointsInsideWindow(x), windowLocations))
    # Get
    predictedNotActualWindowLocations = predictedWindowLocations - actualWindowLocations
    actualNotPredictedWindowLocations = actualWindowLocations - predictedWindowLocations
    wrongWindowLocations = predictedNotActualWindowLocations.union(actualNotPredictedWindowLocations)
    wrongPixelCenters = [image_store.getWindowCenter(x, windowPixelWidth, windowPixelHeight) for x in wrongWindowLocations]
    # Compute
    actualTrue_predictedFalse = len(actualNotPredictedWindowLocations)
    actualFalse_predictedTrue = len(predictedNotActualWindowLocations)
    actualTrue = len(actualWindowLocations)
    actualFalse = windowCount - actualTrue
    predictedTrue = len(predictedWindowLocations)
    predictedFalse = windowCount - predictedTrue
    percentError, falsePositiveError, falseNegativeError = computePercentages(actualTrue_predictedFalse, actualFalse_predictedTrue, actualTrue, actualFalse)
    # Save
    windowPerformance = {
        'percent error': percentError, 
        'false positive error': falsePositiveError,
        'false negative error': falseNegativeError,
        'actual true': actualTrue,
        'actual false': actualFalse,
        'predicted true': predictedTrue,
        'predicted false': predictedFalse,
        'actual true predicted true': actualTrue - actualTrue_predictedFalse,
        'actual true predicted false': actualTrue_predictedFalse,
        'actual false predicted true': actualFalse_predictedTrue,
        'actual false predicted false': actualFalse - actualFalse_predictedTrue,
        'window count': windowCount,
    }
    return windowPerformance, wrongPixelCenters, actualPixelPointMachine