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 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)