def add(imageName, ownerID, parameterByName):
"""
Add an image to a database
"""
# Show feedback
print 'Registering image: ' + imageName
# Check whether the image has already been registered
image = meta.Session.query(model.Image).filter_by(name=imageName).first()
# If the image does not exist,
if not image:
# Register the image in the database
image = model.Image(imageName, ownerID)
meta.Session.add(image)
# Prepare path
basePath = parameterByName.get('path', '')
# Load multispectral image
multispectralImagePath = store.fillPath(basePath, parameterByName['multispectral image'])
multispectralImage = image_store.load(multispectralImagePath)
multispectralSpatialReference = multispectralImage.getSpatialReference()
# Load panchromatic image
panchromaticImagePath = store.fillPath(basePath, parameterByName['panchromatic image'])
panchromaticImage = image_store.load(panchromaticImagePath)
panchromaticSpatialReference = panchromaticImage.getSpatialReference()
# Validate
spatialReference = store.validateSame([multispectralSpatialReference, panchromaticSpatialReference], 'Spatial references do not match: %s' % imageName)
# Update image
image.multispectral_path = multispectralImagePath
image.panchromatic_path = panchromaticImagePath
image.spatial_reference = spatialReference
image.is_complete = True
meta.Session.commit()
def step(taskName, parameterByName, folderStore, options):
# Get parameters
classifierName = parameterByName['classifier name']
classifierPath = folderStore.getClassifierPath(classifierName)
classifierInformation = folderStore.getClassifierInformation(classifierName)
windowLengthInMeters = classifierInformation.getWindowLengthInMeters()
scanRatio = parameterByName['scan ratio']
regionName = parameterByName['region name']
regionPath = folderStore.getRegionPath(regionName)
regionInformation = folderStore.getRegionInformation(regionName)
regionDataset = regionInformation.getRegionDataset()
# Prepare
imageName = regionInformation.getImageName()
imagePath = folderStore.getImagePath(imageName)
imageInformation = folderStore.getImageInformation(imageName)
multispectralImagePath = imageInformation.getMultispectralImagePath()
multispectralImage = image_store.load(multispectralImagePath)
panchromaticImagePath = imageInformation.getPanchromaticImagePath()
positiveLocationPath = imageInformation.getPositiveLocationPath()
regionFrames = regionDataset.getRegionFrames()
# Record
targetProbabilityPath = folderStore.fillProbabilityPath(taskName)
probabilityInformation = {
'classifier': {
'name': classifierName,
'path': classifierPath,
},
'parameters': {
'window length in meters': windowLengthInMeters,
'scan ratio': scanRatio,
},
'probability': {
'region name': regionName,
'region path': regionPath,
'image name': imageName,
'image path': imagePath,
},
}
store.saveInformation(targetProbabilityPath, probabilityInformation)
# If this is not a test,
if not options.is_test:
# Scan
info = classifier.scan(targetProbabilityPath, classifierPath, multispectralImagePath, panchromaticImagePath, scanRatio, regionFrames)
# Save
print 'Saving probability matrix as a shapefile...'
probability_store.saveShapefile(targetProbabilityPath, targetProbabilityPath, image_store.load(multispectralImagePath), windowLengthInMeters)
# Evaluate
print 'Evaluating windows...'
windowPerformance, wrongPixelCenters, actualPixelPointMachine = evaluation_process.evaluateWindows(targetProbabilityPath, positiveLocationPath, multispectralImagePath, windowLengthInMeters)
probabilityInformation['performance'] = windowPerformance
probabilityInformation['performance'].update(info)
else:
wrongPixelCenters = []
windowPixelWidth, windowPixelHeight = multispectralImage.convertGeoDimensionsToPixelDimensions(windowLengthInMeters, windowLengthInMeters)
actualPixelPointMachine = point_process.PointMachine([], 'INTEGER', windowPixelWidth, windowPixelHeight)
# Update
store.saveInformation(targetProbabilityPath, probabilityInformation)
# Build patch
patch_process.buildPatchFromScan(wrongPixelCenters, folderStore, taskName, targetProbabilityPath, multispectralImagePath, panchromaticImagePath, actualPixelPointMachine, classifierInformation, options.is_test)
def defineRegions(targetRegionPath, multispectralImagePath, panchromaticImagePath, parameterByName, options=None):
# Load
targetTestRegionPath = targetRegionPath + '-test'
multispectralImage = image_store.load(str(multispectralImagePath))
panchromaticImage = image_store.load(str(panchromaticImagePath))
regionPath = parameterByName.get('region path')
multispectralRegionFrames = parameterByName.get('multispectral region frames')
windowLengthInMeters = parameterByName.get('window length in meters')
regionLengthInWindows = parameterByName.get('region length in windows')
testFractionPerRegion = parameterByName['test fraction per region']
coverageFraction = parameterByName.get('coverage fraction', 1)
coverageFrequency = int(1 / coverageFraction)
coverageOffset = parameterByName.get('coverage offset', 0)
# If regionPath is defined, use it
if regionPath:
regionGenerator = (x for x in region_store.loadShapefile(regionPath, multispectralImage))
# If multispectralRegionFrames are defined, use them
elif multispectralRegionFrames:
regionGenerator = (x for x in multispectralRegionFrames)
# Otherwise, prepare regionGenerator
else:
regionGenerator = region_store.makeRegionGenerator(multispectralImage, panchromaticImage, regionLengthInWindows, windowLengthInMeters)
# Save regions
regionDataset = region_store.create(targetRegionPath)
testRegionDataset = region_store.create(targetTestRegionPath)
if options and not options.is_test:
for regionIndex, regionWindow in itertools.izip(itertools.count(1), regionGenerator):
if (regionIndex + coverageOffset) % coverageFrequency == 0:
regionDataset.addRegion(regionWindow)
regionFrame = region_store.getMultispectralPixelFrame(regionWindow)
testRegionDataset.addFrame(region_process.placeTestRegion(regionFrame, testFractionPerRegion))
# Save as shapefiles
regionDataset.saveShapefile(targetRegionPath, multispectralImage)
testRegionDataset.saveShapefile(targetTestRegionPath, multispectralImage)
# Prepare information
information = {
'parameters': {
'multispectral image path': multispectralImagePath,
'panchromatic image path': panchromaticImagePath,
'test fraction per region': testFractionPerRegion,
'window length in meters': windowLengthInMeters,
},
'regions': {
'path': regionDataset.getPath(),
'count': regionDataset.count(),
},
'test regions': {
'path': testRegionDataset.getPath(),
'count': testRegionDataset.count(),
},
}
if regionPath:
information['parameters'].update({
'region path': regionPath,
})
elif multispectralRegionFrames:
information['parameters'].update({
'multispectral region frames': store.stringifyNestedList(multispectralRegionFrames),
})
else:
information['parameters'].update({
'region length in windows': regionLengthInWindows,
'coverage fraction': coverageFraction,
'coverage offset': coverageOffset,
})
# Save information
store.saveInformation(targetRegionPath, information)
def step(taskName, parameterByName, folderStore, options):
# Get parameters
imageName = parameterByName['image name']
imagePath = folderStore.getImagePath(imageName)
imageInformation = folderStore.getImageInformation(imageName)
multispectralImagePath = imageInformation.getMultispectralImagePath()
multispectralImage = image_store.load(multispectralImagePath)
scanRatio = float(parameterByName['scan ratio'])
classifierName = parameterByName['classifier name']
classifierPath = folderStore.getClassifierPath(classifierName)
classifierInformation = folderStore.getClassifierInformation(classifierName)
windowLengthInMeters = classifierInformation.getWindowLengthInMeters()
panchromaticImagePath = imageInformation.getPanchromaticImagePath()
positiveLocationPath = imageInformation.getPositiveLocationPath()
coverageFraction = parameterByName.get('coverage fraction', 1)
# Record
targetProbabilityPath = folderStore.fillProbabilityPath(taskName)
regionPath = targetProbabilityPath + '_region'
probabilityInformation = {
'classifier': {
'name': classifierName,
'path': classifierPath,
},
'parameters': {
'window length in meters': windowLengthInMeters,
'scan ratio': scanRatio,
'coverage fraction': coverageFraction,
},
'probability': {
'region path': regionPath,
'image name': imageName,
'image path': imagePath,
},
}
# Run
store.saveInformation(targetProbabilityPath, probabilityInformation)
if not options.is_test:
# Frame
xMax = multispectralImage.width
yMax = multispectralImage.height
xMargin = int(xMax * (1 - coverageFraction) / 2)
yMargin = int(yMax * (1 - coverageFraction) / 2)
regionFrames = [(xMargin, yMargin, xMax - xMargin, yMax - yMargin)]
regionDataset = region_store.save(regionPath, regionFrames)
regionDataset.saveShapefile(regionPath, multispectralImage)
# Scan
info = classifier.scan(targetProbabilityPath, classifierPath, multispectralImagePath, panchromaticImagePath, scanRatio, regionFrames)
# Save
print 'Saving probability matrix as a shapefile...'
probability_store.saveShapefile(targetProbabilityPath, targetProbabilityPath, multispectralImage, windowLengthInMeters)
# Evaluate windows
windowPerformance, wrongPixelCenters, actualPixelPointMachine = evaluation_process.evaluateWindows(targetProbabilityPath, positiveLocationPath, multispectralImagePath, windowLengthInMeters)
probabilityInformation['performance'] = windowPerformance
probabilityInformation['performance'].update(info)
else:
wrongPixelCenters = []
windowPixelWidth, windowPixelHeight = multispectralImage.convertGeoDimensionsToPixelDimensions(windowLengthInMeters, windowLengthInMeters)
actualPixelPointMachine = point_process.PointMachine([], 'INTEGER', windowPixelWidth, windowPixelHeight)
# Update
store.saveInformation(targetProbabilityPath, probabilityInformation)
# Save patch
patch_process.buildPatchFromScan(wrongPixelCenters, folderStore, taskName, targetProbabilityPath, multispectralImagePath, panchromaticImagePath, actualPixelPointMachine, classifierInformation, options.is_test)
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)
