def extractDataset(targetDatasetPath, paths, parameters):
# Unpack
multispectralImagePath, panchromaticImagePath, positiveLocationPath = paths
windowGeoLength, negativeRatio, multispectralPixelShiftValue, shiftCount = parameters
# Show feedback
view.sendFeedback('Extracting dataset...\n\ttargetDatasetPath = %s' % targetDatasetPath)
# Extract samples
extractor = Extractor(targetDatasetPath, windowGeoLength, multispectralPixelShiftValue, shiftCount, negativeRatio)
extractor.extractSamples(positiveLocationPath, multispectralImagePath, panchromaticImagePath)
# Record
targetDataset = extractor.getSampleDatabase()
multispectralImage = image_store.load(multispectralImagePath)
panchromaticImage = image_store.load(panchromaticImagePath)
points, spatialReference = point_store.load(positiveLocationPath)
store.saveInformation(targetDatasetPath, {
'multispectral image': {
'path': multispectralImagePath,
'pixel width': multispectralImage.getPixelWidth(),
'pixel height': multispectralImage.getPixelHeight(),
'geo transform': multispectralImage.getGeoTransform(),
},
'panchromatic image': {
'path': panchromaticImagePath,
'pixel width': panchromaticImage.getPixelWidth(),
'pixel height': panchromaticImage.getPixelHeight(),
'geo transform': panchromaticImage.getGeoTransform(),
},
'positive location': {
'path': positiveLocationPath,
'location count': len(points),
'spatial reference': spatialReference,
},
'windows': {
'path': targetDatasetPath,
'sample count': targetDataset.countSamples(),
'positive sample count': targetDataset.countPositiveSamples(),
'negative sample count': targetDataset.countNegativeSamples(),
},
'parameters': {
'window geo length': windowGeoLength,
'multispectral pixel shift value': multispectralPixelShiftValue,
'shift count': shiftCount,
'negative ratio': negativeRatio,
}
})
# Return
return targetDataset
def extractSamples(self, positiveLocationPath, multispectralImagePath, panchromaticImagePath):
view.sendFeedback('Loading images...\n\tmultispectralImagePath = %s\n\tpanchromaticImagePath = %s' % (multispectralImagePath, panchromaticImagePath))
multispectralImage = image_store.load(multispectralImagePath)
panchromaticImage = image_store.load(panchromaticImagePath)
view.sendFeedback('Generating geoCenters...\n\tmultispectralPixelShiftValue = %s\n\tshiftCount = %s\n\tnegativeRatio = %s' % (self.multispectralPixelShiftValue, self.shiftCount, self.negativeRatio))
positiveMultispectralPixelCenters = self.loadPixelCenters(multispectralImage, positiveLocationPath)
negativeMultispectralPixelCenters = self.makePixelCenters(multispectralImage, positiveMultispectralPixelCenters)
positiveGeoCenters = multispectralImage.convertPixelLocationsToGeoLocations(positiveMultispectralPixelCenters)
negativeGeoCenters = multispectralImage.convertPixelLocationsToGeoLocations(negativeMultispectralPixelCenters)
view.sendFeedback('Extracting positive samples...')
self.extract(1, positiveGeoCenters, multispectralImage, panchromaticImage)
view.sendFeedback('Extracting negative samples...')
self.extract(0, negativeGeoCenters, multispectralImage, panchromaticImage)
def combineDatasets(targetDatasetPath, datasetPaths, datasetSize=None, positiveFraction=None):
# If positiveFraction is defined,
if positiveFraction:
# Get
positiveSamplePacks = []
negativeSamplePacks = []
for dataset in itertools.imap(sample_store.load, datasetPaths):
positiveSamplePacks.extend((dataset, x) for x in dataset.getPositiveSampleIDs())
negativeSamplePacks.extend((dataset, x) for x in dataset.getNegativeSampleIDs())
# Shuffle
random.shuffle(positiveSamplePacks)
random.shuffle(negativeSamplePacks)
# Count
totalPositiveCount = len(positiveSamplePacks)
totalNegativeCount = len(negativeSamplePacks)
# Chop
# if positiveFraction >= 0.5:
multiplier = (1 - positiveFraction) / positiveFraction
scaledNegativeCount = int(multiplier * totalPositiveCount)
datasetSampleIDs = positiveSamplePacks + negativeSamplePacks[:scaledNegativeCount]
# else:
# multiplier = positiveFraction / (1 - positiveFraction)
# scaledPositiveCount = int(multiplier * totalNegativeCount)
# datasetSampleIDs = positiveSamplePacks[:scaledPositiveCount] + negativeSamplePacks
# If positiveFraction is not defined,
else:
# Get sampleIDs
datasetSampleIDs = []
for dataset in itertools.imap(sample_store.load, datasetPaths):
datasetSampleIDs.extend((dataset, x) for x in dataset.getSampleIDs())
# Shuffle
random.shuffle(datasetSampleIDs)
# Subset
selectedDatasetSampleIDs = datasetSampleIDs[:datasetSize] if datasetSize else datasetSampleIDs
view.sendFeedback('Making dataset with %d samples...' % len(selectedDatasetSampleIDs))
return sample_store.save(targetDatasetPath, selectedDatasetSampleIDs)