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)