def test_encode(self):
aa = AreaAnalyst(self.r1, self.r1)
self.assertEqual(aa.categories, [0, 1, 2, 3])
self.assertEqual(aa.encode(1, 2), 6)
for initClass in range(4):
for finalClass in range(4):
k = aa.encode(initClass, finalClass)
self.assertEqual(aa.decode(k), (initClass, finalClass))
self.assertEqual(aa.finalCodes(0), [0, 1, 2, 3])
self.assertEqual(aa.finalCodes(1), [4, 5, 6, 7])
def test_encode(self):
aa = AreaAnalyst(self.r1, self.r1)
self.assertEqual(aa.classes, [0,1,2,3])
self.assertEqual(aa.encode(1,2), 6)
for initClass in range(4):
for finalClass in range(4):
k = aa.encode(initClass, finalClass)
self.assertEqual(aa.decode(k), (initClass, finalClass))
self.assertEqual(aa.finalCodes(0), [0,1,2,3])
self.assertEqual(aa.finalCodes(1), [4,5,6,7])
def sim(self):
"""
Make 1 iteracion of simulation.
"""
# TODO: eleminate AreaAnalyst.getChangeMap() from the process
transition = self.crosstable.getCrosstable()
prediction = self.getPrediction()
state = self.getState()
new_state = state.getBand(1).copy() # New states (the result of simulation) will be stored there.
analyst = AreaAnalyst(state, prediction)
classes = analyst.classes
changes = analyst.getChangeMap().getBand(1)
# Make transition between classes according to
# number of moved pixel in crosstable
self.rangeChanged.emit(self.tr("Simulation process %p%"), len(classes) ** 2 - len(classes))
for initClass in classes:
for finalClass in classes:
if initClass == finalClass:
continue
# TODO: Calculate number of pixels to be moved via TransitoionMatrix and state raster
n = transition.getTransition(
initClass, finalClass
) # Number of pixels to be moved (constant count now).
# Find n appropriate places for transition initClass -> finalClass
class_code = analyst.encode(initClass, finalClass)
places = changes == class_code # Array of places where transitions initClass -> finalClass are occured
placesCount = np.sum(places)
if placesCount < n:
self.logMessage.emit(
self.tr("There are more transitions in the transition matrix, then the model have found")
)
n = placesCount
confidence = self.getConfidence().getBand(1)
confidence = (
confidence * places
) # The higher is number in cell, the higer is probability of transition in the cell
indices = []
for i in range(n):
index = np.unravel_index(
confidence.argmax(), confidence.shape
) # Select the cell with biggest probability
indices.append(index)
confidence[index] = -1 # Mark the cell to prevent second selection
# Now "indices" contains indices of the appropriate places,
# make transition initClass -> finalClass
for index in indices:
new_state[index] = finalClass
self.updateProgress.emit()
result = Raster()
result.create([new_state], state.getGeodata())
self.state = result
self.updatePrediction(result)
self.processFinished.emit()
def __sim(self):
'''
1 iteracion of simulation.
'''
transition = self.crosstable.getCrosstable()
self.updatePrediction(self.state)
changes = self.getPrediction().getBand(1) # Predicted change map
changes = changes + 1 # Filling nodata as 0 can be ambiguous:
changes = np.ma.filled(changes, 0) # (cat_code can be 0, to do not mix it with no-data, add 1)
state = self.getState()
new_state = state.getBand(1).copy().astype(np.uint8) # New states (the result of simulation) will be stored there.
self.rangeChanged.emit(self.tr("Area Change Analysis %p%"), 2)
self.updateProgress.emit()
QCoreApplication.processEvents()
analyst = AreaAnalyst(state, second = None)
self.updateProgress.emit()
QCoreApplication.processEvents()
categories = state.getBandGradation(1)
# Make transition between categories according to
# number of moved pixel in crosstable
self.rangeChanged.emit(self.tr("Simulation process %p%"), len(categories)**2 - len(categories))
QCoreApplication.processEvents()
for initClass in categories:
for finalClass in categories:
if initClass == finalClass: continue
# TODO: Calculate number of pixels to be moved via TransitionMatrix and state raster
n = transition.getTransition(initClass, finalClass) # Number of pixels that have to be
# changed the categories
# (use TransitoionMatrix only).
if n==0:
continue
# Find n appropriate places for transition initClass -> finalClass
cat_code = analyst.encode(initClass, finalClass)
# Array of places where transitions initClass -> finalClass are occured
places = (changes==cat_code+1) # cat_code can be 0, do not mix it with no-data in 'changes' variable
placesCount = np.sum(places)
# print "cat_code, placesCount, n", cat_code, placesCount
if placesCount < n:
self.logMessage.emit(self.tr("There are more transitions in the transition matrix, then the model have found"))
# print "There are more transitions in the transition matrix, then the model have found"
# print "cat_code, placesCount, n", cat_code, placesCount, n
QCoreApplication.processEvents()
n = placesCount
if n >0:
confidence = self.getConfidence().getBand(1)
# Add some random value
rnd = np.random.sample(size=confidence.shape)/1000 # A small random
confidence = np.ma.filled(confidence, 0) + rnd
confidence = confidence * places # The higher is number in cell, the higer is probability of transition in the cell.
# Ensure, n is bigger then nonzero confidence
placesCount = np.sum(confidence>0)
if placesCount < n: # Some confidence where transitions has to be appear is zero. The transition count will be cropped.
# print "Some confidence is zero. cat_code, nonzeroConf, wantedPixels", cat_code, placesCount, n
n = placesCount
ind = confidence.argsort(axis=None)[-n:]
indices = [np.unravel_index(i, confidence.shape) for i in ind]
# Now "indices" contains indices of the appropriate places,
# make transition initClass -> finalClass
r1 = np.zeros(confidence.shape)
for index in indices:
new_state[index] = finalClass
self.updateProgress.emit()
QCoreApplication.processEvents()
result = Raster()
result.create([new_state], state.getGeodata())
self.state = result
def __sim(self):
'''
1 iteracion of simulation.
'''
transition = self.crosstable.getCrosstable()
self.updatePrediction(self.state)
changes = self.getPrediction().getBand(1) # Predicted change map
changes = changes + 1 # Filling nodata as 0 can be ambiguous:
changes = np.ma.filled(
changes,
0) # (cat_code can be 0, to do not mix it with no-data, add 1)
state = self.getState()
new_state = state.getBand(1).copy().astype(
np.uint8
) # New states (the result of simulation) will be stored there.
self.rangeChanged.emit(self.tr("Area Change Analysis %p%"), 2)
self.updateProgress.emit()
QCoreApplication.processEvents()
analyst = AreaAnalyst(state, second=None)
self.updateProgress.emit()
QCoreApplication.processEvents()
categories = state.getBandGradation(1)
# Make transition between categories according to
# number of moved pixel in crosstable
self.rangeChanged.emit(self.tr("Simulation process %p%"),
len(categories)**2 - len(categories))
QCoreApplication.processEvents()
for initClass in categories:
for finalClass in categories:
if initClass == finalClass: continue
# TODO: Calculate number of pixels to be moved via TransitionMatrix and state raster
n = transition.getTransition(
initClass, finalClass) # Number of pixels that have to be
# changed the categories
# (use TransitoionMatrix only).
if n == 0:
continue
# Find n appropriate places for transition initClass -> finalClass
cat_code = analyst.encode(initClass, finalClass)
# Array of places where transitions initClass -> finalClass are occured
places = (
changes == cat_code + 1
) # cat_code can be 0, do not mix it with no-data in 'changes' variable
placesCount = np.sum(places)
# print "cat_code, placesCount, n", cat_code, placesCount
if placesCount < n:
self.logMessage.emit(
self.
tr("There are more transitions in the transition matrix, then the model have found"
))
# print "There are more transitions in the transition matrix, then the model have found"
# print "cat_code, placesCount, n", cat_code, placesCount, n
QCoreApplication.processEvents()
n = placesCount
if n > 0:
confidence = self.getConfidence().getBand(1)
# Add some random value
rnd = np.random.sample(
size=confidence.shape) / 1000 # A small random
confidence = np.ma.filled(confidence, 0) + rnd
confidence = confidence * places # The higher is number in cell, the higer is probability of transition in the cell.
# Ensure, n is bigger then nonzero confidence
placesCount = np.sum(confidence > 0)
if placesCount < n: # Some confidence where transitions has to be appear is zero. The transition count will be cropped.
# print "Some confidence is zero. cat_code, nonzeroConf, wantedPixels", cat_code, placesCount, n
n = placesCount
ind = confidence.argsort(axis=None)[-n:]
indices = [
np.unravel_index(i, confidence.shape) for i in ind
]
# Now "indices" contains indices of the appropriate places,
# make transition initClass -> finalClass
r1 = np.zeros(confidence.shape)
for index in indices:
new_state[index] = finalClass
self.updateProgress.emit()
QCoreApplication.processEvents()
result = Raster()
result.create([new_state], state.getGeodata())
self.state = result
