def evaluateWindowsByRadius(probabilityPath, geoRadius):
# Initialize
print 'Evaluating windows with %s meter radius...' % geoRadius
scanInformation = probability_store.Information(probabilityPath)
multispectralImage, panchromaticImage, actualGeoCenters, windowPixelDimensions = scanInformation.getPackage()
geoDiameter = float(geoRadius) * 2
# Get predictedGeoCenters
predictedPixelCenters = probability_store.loadPredictedPixelCenters(probabilityPath, windowPixelDimensions)
predictedGeoCenters = multispectralImage.convertPixelLocationsToGeoLocations(predictedPixelCenters)
# Get
actualNotPredictedCenters = point_process.extractBadLocations(geoDiameter, actualGeoCenters, predictedGeoCenters)
predictedNotActualCenters = point_process.extractBadLocations(geoDiameter, predictedGeoCenters, actualGeoCenters)
# Count
actual = len(actualGeoCenters)
predicted = len(predictedGeoCenters)
actualNotPredicted = len(actualNotPredictedCenters)
predictedNotActual = len(predictedNotActualCenters)
actualAndPredicted = len(actualGeoCenters) - actualNotPredicted
predictedAndActual = len(predictedGeoCenters) - predictedNotActual
return {
'evaluation radius in meters': geoRadius,
'actual count': actual,
'predicted count': predicted,
'actual not predicted count': actualNotPredicted,
'predicted not actual count': predictedNotActual,
'predicted and actual count': predictedAndActual,
'actual and predicted count': actualAndPredicted,
'pNa/p': predictedNotActual / float(predicted) if predicted else None,
'aNp/a': actualNotPredicted / float(actual) if actual else None,
'precision': predictedAndActual / float(predicted) if predicted else None,
'recall': actualAndPredicted / float(actual) if actual else None,
}
def evaluateWindowsByRegions(probabilityPath, regionPixelFrames):
# Load
scanInformation = probability_store.Information(probabilityPath)
# Initialize
multispectralImage, panchromaticImage, actualGeoCenters, windowPixelDimensions = scanInformation.getPackage()
regionCount = len(regionPixelFrames)
regionLabels_actual = numpy.zeros(regionCount)
pixelCenters_actual = multispectralImage.convertGeoLocationsToPixelLocations(actualGeoCenters)
regionLabels_predicted = numpy.zeros(len(regionPixelFrames))
pixelCenters_predicted = probability_store.loadPredictedPixelCenters(probabilityPath, windowPixelDimensions)
# Build machines
pointMachine_actual = point_process.PointMachine(pixelCenters_actual, 'INTEGER')
pointMachine_predicted = point_process.PointMachine(pixelCenters_predicted, 'INTEGER')
# For each region,
print 'Evaluating windows by region...'
for regionIndex, regionPixelFrame in enumerate(regionPixelFrames):
# Determine actual label
regionLabels_actual[regionIndex] = 1 if pointMachine_actual.getPointsInsideFrame(regionPixelFrame) else 0
# Determine predicted label
regionLabels_predicted[regionIndex] = 1 if pointMachine_predicted.getPointsInsideFrame(regionPixelFrame) else 0
# Show feedback
if regionIndex % 100 == 0:
view.printPercentUpdate(regionIndex, len(regionPixelFrames))
# Show feedback
view.printPercentFinal(len(regionPixelFrames))
# Compute
truePositive = sum((regionLabels_actual == 1) * (regionLabels_predicted == 1))
trueNegative = sum((regionLabels_actual == 0) * (regionLabels_predicted == 0))
falsePositive = sum((regionLabels_actual == 0) * (regionLabels_predicted == 1))
falseNegative = sum((regionLabels_actual == 1) * (regionLabels_predicted == 0))
actualPositive = sum(regionLabels_actual == 1)
actualNegative = sum(regionLabels_actual == 0)
# Count
actualCount = sum(regionLabels_actual)
predictedCount = sum(regionLabels_predicted)
# Return
return {
'region count': regionCount,
'true positive count': truePositive,
'true positive rate': truePositive / float(actualPositive) if actualPositive else None,
'true negative count': trueNegative,
'false positive count': falsePositive,
'false positive rate': falsePositive / float(actualNegative) if actualNegative else None,
'false negative count': falseNegative,
'actual positive count': actualCount,
'predicted positive count': predictedCount,
'precision': truePositive / float(predictedCount) if predictedCount else None,
'recall': truePositive / float(actualCount) if actualCount else None,
}
