def step(taskName, parameterByName, folderStore, options):
# Get
windowGeoLength = parameterByName['window length in meters']
windowLabel = parameterByName['window label']
windowCenterPath = parameterByName['window center path']
imageName = parameterByName['image name']
imagePath = folderStore.getImagePath(imageName)
imageInformation = folderStore.getImageInformation(imageName)
# Prepare
geoCenters, spatialReference = point_store.load(windowCenterPath)
multispectralImage = imageInformation.getMultispectralImage()
panchromaticImage = imageInformation.getPanchromaticImage()
# Set
targetWindowPath = folderStore.fillWindowPath(taskName)
exampleInformation = {}
# Extract
if not options.is_test:
dataset = window_process.extract(targetWindowPath, geoCenters, windowLabel, windowGeoLength, multispectralImage, panchromaticImage)
exampleInformation['count'] = dataset.countSamples()
# Save
store.saveInformation(targetWindowPath, {
'windows': {
'window length in meters': windowGeoLength,
'spatial reference': spatialReference,
},
'parameters': {
'window label': windowLabel,
'window center path': windowCenterPath,
'image name': imageName,
'image path': imagePath,
},
'examples': exampleInformation,
})
def step(taskName, parameterByName, folderStore, options):
# Get
patchCountPerRegion = parameterByName['patch count per region']
minimumPercentCorrect = parameterByName['minimum percent correct']
probabilityName = parameterByName['probability name']
probabilityPath = folderStore.getProbabilityPath(probabilityName)
probabilityInformation = probability_store.Information(probabilityPath)
imageName = probabilityInformation.getImageName()
imageInformation = folderStore.getImageInformation(imageName)
multispectralImage = imageInformation.getMultispectralImage()
panchromaticImage = imageInformation.getPanchromaticImage()
positiveLocationPath = imageInformation.getPositiveLocationPath()
positiveGeoLocations, spatialReference = point_store.load(positiveLocationPath)
# If the probability is from scanning the entire image,
if not probabilityInformation.hasRegionName():
regionPath = folderStore.getRegionPath(parameterByName['region name'])
# Get regionDataset
else:
regionPath = probabilityInformation.getRegionPath()
regionInformation = region_store.Information(regionPath)
regionFrames = regionInformation.getRegionDataset().getRegionFrames()
regionCount = len(regionFrames)
testRegionDataset = regionInformation.getTestRegionDataset()
# Get windowPixelDimensions
windowLengthInMeters = probabilityInformation.getWindowLengthInMeters()
windowPixelDimensions = multispectralImage.convertGeoDimensionsToPixelDimensions(windowLengthInMeters, windowLengthInMeters)
# Get classifierInformation
classifierPath = probabilityInformation.getClassifierPath()
classifierInformation = classifier.Information(classifierPath)
# Record
information = {
'patches': {
'patch count per region': patchCountPerRegion,
'minimum percent correct': minimumPercentCorrect,
'probability name': probabilityName,
'probability path': probabilityPath,
},
'windows': {
'window length in meters': windowLengthInMeters,
'spatial reference': spatialReference,
},
}
# Set
targetPatchPath = folderStore.fillPatchPath(taskName)
targetPatchFolderPath = os.path.dirname(targetPatchPath)
if not options.is_test:
# Make pixelPointMachines
trainingPixelPointMachine = point_process.makePixelPointMachine(classifierInformation.getTrainingDataset().getGeoCenters(), windowLengthInMeters, multispectralImage)
testPixelPointMachine = point_process.makePixelPointMachine(classifierInformation.getTestDataset().getGeoCenters(), windowLengthInMeters, multispectralImage)
actualPixelPointMachine = point_process.makePixelPointMachine(positiveGeoLocations, windowLengthInMeters, multispectralImage)
# Get badRegionFrames
print 'Finding regions with poor performance...'
isGoodWindow = actualPixelPointMachine.getPointsInsideWindow
probabilityPacks = probability_store.load(probabilityPath)
performances = analyzeRegions(regionFrames, probabilityPacks, isGoodWindow)
badRegionFrames = [x[0] for x in itertools.izip(regionFrames, performances) if x[1] < minimumPercentCorrect]
badRegionCount = len(badRegionFrames)
# Save badRegionFrames
badRegionDataset = region_store.save(targetPatchPath, badRegionFrames)
badRegionDataset.saveShapefile(targetPatchPath, multispectralImage)
# Make patch window centers
print 'Sampling from regions with poor performance...'
testPatchPixelCenters = []
trainingPatchPixelCenters = []
for regionFrame in badRegionFrames:
# Load badCenters
testRegionFrame = testRegionDataset.getFrameInsideFrame(regionFrame)
regionalTrainingPixelCenters = trainingPixelPointMachine.getPointsInsideFrame(regionFrame)
regionalTestPixelCenters = testPixelPointMachine.getPointsInsideFrame(testRegionFrame)
badCenters = regionalTrainingPixelCenters + regionalTestPixelCenters
# Generate patch window centers
centerMachine = sample_process.CenterMachine(regionFrame, windowPixelDimensions, badCenters)
for patchWindowPixelCenter in centerMachine.makeCenters(patchCountPerRegion):
if point_process.isInsideRegion(patchWindowPixelCenter, testRegionFrame):
testPatchPixelCenters.append(patchWindowPixelCenter)
else:
trainingPatchPixelCenters.append(patchWindowPixelCenter)
# Define
buildPatch = lambda makePath, pixelCenters: patch_process.buildPatch(makePath(targetPatchFolderPath), pixelCenters, actualPixelPointMachine, multispectralImage, panchromaticImage, windowLengthInMeters)
# Produce training and test sets
information['training set'] = buildPatch(sample_process.makeTrainingPath, trainingPatchPixelCenters).getStatistics()
information['test set'] = buildPatch(sample_process.makeTestPath, testPatchPixelCenters).getStatistics()
# Record
information['performance'] = {
'bad region count': badRegionCount,
'region count': regionCount,
'percent correct': (regionCount - badRegionCount) / float(regionCount),
}
information['performance by region'] = dict(('%s %s %s %s' % x[0], x[1]) for x in itertools.izip(regionFrames, performances))
# Save
store.saveInformation(targetPatchPath, information)
def sampleWindows(targetWindowPath, region, location, parameterByName, options=None):
# Get parameters
exampleCountPerRegion = parameterByName['example count per region']
multispectralPixelShiftValue = parameterByName['multispectral pixel shift value']
shiftCount = parameterByName['shift count']
# Prepare regionFrames
regionSet = region.getDataset()
# regionDataset = region_store.load(region.path)
regionFrames = regionDataset.getRegionFrames()
regionFrameCount = len(regionFrames)
# Prepare counts
testRegionSet = region.getTestDataset()
# testRegionDataset = region_store.load(regionInformation.getTestRegionPath())
testFractionPerRegion = regionInformation.getTestFractionPerRegion()
# Load imageDataset
imagePath = folderStore.getImagePath(regionInformation.getImageName())
imageInformation = image_store.Information(imagePath)
multispectralImage = image_store.load(imageInformation.getMultispectralImagePath())
panchromaticImage = image_store.load(imageInformation.getPanchromaticImagePath())
# Load locations
positiveGeoLocations, spatialReference = point_store.load(imageInformation.getPositiveLocationPath())
# Convert
windowLengthInMeters = regionInformation.getWindowLengthInMeters()
windowPixelDimensions = multispectralImage.convertGeoDimensionsToPixelDimensions(windowLengthInMeters, windowLengthInMeters)
positivePixels = multispectralImage.convertGeoLocationsToPixelLocations(positiveGeoLocations)
# Place examples
exampleMachine = region_process.ExampleMachine(positivePixels, exampleCountPerRegion, testFractionPerRegion, testRegionDataset, windowPixelDimensions, multispectralPixelShiftValue, shiftCount)
examplePacks = []
if options and not options.is_test:
print 'Placing examples in %s regions for "%s"...' % (regionFrameCount, taskName)
for regionFrame in regionFrames:
examplePacks.append(exampleMachine.placeInFrame(regionFrame))
exampleCount = len(examplePacks)
if exampleCount % 10 == 0:
view.printPercentUpdate(exampleCount, regionFrameCount)
view.printPercentFinal(regionFrameCount)
exampleInformation = {}
trainingPaths = []
testPaths = []
# Set
targetWindowFolderPath = os.path.dirname(targetWindowPath)
if options and not options.is_test:
# For each exampleName,
for exampleName in examplePacks[0].keys():
# Convert
examplePixelLocations = sum((x[exampleName] for x in examplePacks), [])
exampleGeoLocations = multispectralImage.convertPixelLocationsToGeoLocations(examplePixelLocations)
examplePath = os.path.join(targetWindowFolderPath, exampleName)
exampleLabel = 1 if 'positive' in exampleName else 0
# Save
point_store.save(examplePath, exampleGeoLocations, spatialReference)
exampleInformation[exampleName + ' count'] = len(examplePixelLocations)
# Extract
print 'Extracting %s windows for %s...' % (len(examplePixelLocations), exampleName)
window_process.extract(examplePath, exampleGeoLocations, exampleLabel, windowLengthInMeters, multispectralImage, panchromaticImage)
(testPaths if 'test' in exampleName else trainingPaths).append(examplePath)
# Record
information = {
'windows': {
'window length in meters': windowLengthInMeters,
'spatial reference': spatialReference,
},
'regions': {
'name': regionName,
'path': regionPath,
'count': regionFrameCount,
},
'examples': exampleInformation,
}
# Combine
if options and not options.is_test:
information['training set'] = sample_process.combineDatasets(sample_process.makeTrainingPath(targetWindowFolderPath), trainingPaths).getStatistics()
information['test set'] = sample_process.combineDatasets(sample_process.makeTestPath(targetWindowFolderPath), testPaths).getStatistics()
# Save information
store.saveInformation(targetWindowPath, information)