def calculate(self):
"""Calculates the nearest neighbor statistic."""
#### Attribute Shortcuts ####
ssdo = self.ssdo
gaTable = ssdo.gaTable
N = ssdo.numObs
studyArea = self.studyArea
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84007), 0, N, 1)
#### Create k-Nearest Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaConcept = self.concept.lower()
gaSearch.init_nearest(0.0, 1, gaConcept)
neighDist = ARC._ss.NeighborDistances(gaTable, gaSearch)
distances = NUM.empty((N,), float)
#### Add All NN Distances ####
for row in xrange(N):
distances[row] = neighDist[row][-1][0]
ARCPY.SetProgressorPosition()
maxDist = distances.max()
if ssdo.useChordal:
hardMaxExtent = ARC._ss.get_max_gcs_distance(ssdo.spatialRef)
if maxDist > hardMaxExtent:
ARCPY.AddIDMessage("ERROR", 1609)
raise SystemExit()
#### Calculate Mean Nearest Neighbor Distance ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84007))
observedMeanDist = distances.mean()
#### Calculate Expected Mean Nearest Neighbor Distance ####
expectedMeanDist = 1.0 / (2.0 * ((N / studyArea)**0.5))
#### Calculate the Z-Score ####
standardError = 0.26136 / ((N**2.0 / studyArea)**0.5)
#### Verify Results ####
check1 = abs(expectedMeanDist) > 0.0
check2 = abs(standardError) > 0.0
if not (check1 and check2):
ARCPY.AddIDMessage("Error", 907)
raise SystemExit()
#### Calculate Statistic ####
ratio = observedMeanDist / expectedMeanDist
zScore = (observedMeanDist - expectedMeanDist) / standardError
pVal = STATS.zProb(zScore, type = 2)
#### Set Attributes ####
self.nn = observedMeanDist
self.en = expectedMeanDist
self.ratio = ratio
self.zn = zScore
self.pVal = pVal
def calculate(self):
"""Calculates the nearest neighbor statistic."""
#### Attribute Shortcuts ####
ssdo = self.ssdo
gaTable = ssdo.gaTable
N = ssdo.numObs
studyArea = self.studyArea
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84007), 0, N, 1)
#### Create k-Nearest Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaConcept = self.concept.lower()
gaSearch.init_nearest(0.0, 1, gaConcept)
neighDist = ARC._ss.NeighborDistances(gaTable, gaSearch)
distances = NUM.empty((N, ), float)
#### Add All NN Distances ####
for row in xrange(N):
distances[row] = neighDist[row][-1][0]
ARCPY.SetProgressorPosition()
maxDist = distances.max()
if ssdo.useChordal:
hardMaxExtent = ARC._ss.get_max_gcs_distance(ssdo.spatialRef)
if maxDist > hardMaxExtent:
ARCPY.AddIDMessage("ERROR", 1609)
raise SystemExit()
#### Calculate Mean Nearest Neighbor Distance ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84007))
observedMeanDist = distances.mean()
#### Calculate Expected Mean Nearest Neighbor Distance ####
expectedMeanDist = 1.0 / (2.0 * ((N / studyArea)**0.5))
#### Calculate the Z-Score ####
standardError = 0.26136 / ((N**2.0 / studyArea)**0.5)
#### Verify Results ####
check1 = abs(expectedMeanDist) > 0.0
check2 = abs(standardError) > 0.0
if not (check1 and check2):
ARCPY.AddIDMessage("Error", 907)
raise SystemExit()
#### Calculate Statistic ####
ratio = observedMeanDist / expectedMeanDist
zScore = (observedMeanDist - expectedMeanDist) / standardError
pVal = STATS.zProb(zScore, type=2)
#### Set Attributes ####
self.nn = observedMeanDist
self.en = expectedMeanDist
self.ratio = ratio
self.zn = zScore
self.pVal = pVal
def knnDecision(ssdo):
"""If no peak autocorrelation distance is found, then return the average
at which all features have a desired set of nearest neighbors. This value
is scaled to be larger than 3 and no larger than 30. If computed value is
larger than 1 standard distance, then return the standard distance
instead.
INPUTS:
ssdo (class): instance of Spatial Stats Data Object
"""
numNeighs = int(ssdo.numObs * .05)
if numNeighs < minNumNeighsSet:
numNeighs = minNumNeighsSet
if numNeighs > maxNumNeighsSet:
numNeighs = maxNumNeighsSet
#### KNN Subject ####
msg = ARCPY.GetIDMessage(84463)
ARCPY.SetProgressor("step", msg, 0, ssdo.numObs, 1)
printOHSSubject(84463, addNewLine = False)
#### Create k-Nearest Neighbor Search Type ####
gaTable = ssdo.gaTable
gaSearch = GAPY.ga_nsearch(gaTable)
gaSearch.init_nearest(0.0, numNeighs, 'euclidean')
neighDist = ARC._ss.NeighborDistances(gaTable, gaSearch)
N = len(gaTable)
distances = NUM.empty((N, ), float)
#### Find All Nearest Neighbor Distance ####
for row in xrange(N):
distances[row] = neighDist[row][-1][-1]
ARCPY.SetProgressorPosition()
#### Make Sure it is not Larger Than Standard Distance ####
meanDist = distances.mean()
if ssdo.useChordal:
distValue = meanDist
distanceStr = ssdo.distanceInfo.printDistance(distValue)
msg = ARCPY.GetIDMessage(84464).format(numNeighs, distanceStr)
else:
sd = UTILS.standardDistanceCutoff(ssdo.xyCoords)
if meanDist > sd:
distValue = sd
distanceStr = ssdo.distanceInfo.printDistance(distValue)
msg = ARCPY.GetIDMessage(84465).format(distanceStr)
else:
distValue = meanDist
distanceStr = ssdo.distanceInfo.printDistance(distValue)
msg = ARCPY.GetIDMessage(84464).format(numNeighs, distanceStr)
#### KNN/STD Answer ####
printOHSAnswer(msg)
return distValue
def knnDecision(ssdo):
"""If no peak autocorrelation distance is found, then return the average
at which all features have a desired set of nearest neighbors. This value
is scaled to be larger than 3 and no larger than 30. If computed value is
larger than 1 standard distance, then return the standard distance
instead.
INPUTS:
ssdo (class): instance of Spatial Stats Data Object
"""
numNeighs = int(ssdo.numObs * .05)
if numNeighs < minNumNeighsSet:
numNeighs = minNumNeighsSet
if numNeighs > maxNumNeighsSet:
numNeighs = maxNumNeighsSet
#### KNN Subject ####
msg = ARCPY.GetIDMessage(84463)
ARCPY.SetProgressor("step", msg, 0, ssdo.numObs, 1)
printOHSSubject(84463, addNewLine=False)
#### Create k-Nearest Neighbor Search Type ####
gaTable = ssdo.gaTable
gaSearch = GAPY.ga_nsearch(gaTable)
gaSearch.init_nearest(0.0, numNeighs, 'euclidean')
neighDist = ARC._ss.NeighborDistances(gaTable, gaSearch)
N = len(gaTable)
distances = NUM.empty((N, ), float)
#### Find All Nearest Neighbor Distance ####
for row in xrange(N):
distances[row] = neighDist[row][-1][-1]
ARCPY.SetProgressorPosition()
#### Make Sure it is not Larger Than Standard Distance ####
meanDist = distances.mean()
if ssdo.useChordal:
distValue = meanDist
distanceStr = ssdo.distanceInfo.printDistance(distValue)
msg = ARCPY.GetIDMessage(84464).format(numNeighs, distanceStr)
else:
sd = UTILS.standardDistanceCutoff(ssdo.xyCoords)
if meanDist > sd:
distValue = sd
distanceStr = ssdo.distanceInfo.printDistance(distValue)
msg = ARCPY.GetIDMessage(84465).format(distanceStr)
else:
distValue = meanDist
distanceStr = ssdo.distanceInfo.printDistance(distValue)
msg = ARCPY.GetIDMessage(84464).format(numNeighs, distanceStr)
#### KNN/STD Answer ####
printOHSAnswer(msg)
return distValue
def __init__(self,
ssdo,
dependentVar,
independentVars,
weightsFile,
outputReportFile=None,
outputTable=None,
maxIndVars=5,
minIndVars=1,
minR2=.5,
maxCoef=.01,
maxVIF=5.0,
minJB=.1,
minMI=.1):
ARCPY.env.overwriteOutput = True
#### Set Initial Attributes ####
UTILS.assignClassAttr(self, locals())
self.masterField = self.ssdo.masterField
self.warnedTProb = False
#### Set Boolean For Passing All Moran's I ####
self.allMIPass = UTILS.compareFloat(0.0, self.minMI, rTol=.00000001)
#### Assess Whether SWM File Being Used ####
if weightsFile:
weightSuffix = weightsFile.split(".")[-1].lower()
if weightSuffix == "swm":
self.weightsType = "SWM"
self.weightsMatrix = self.weightsFile
else:
self.weightsType = "GWT"
self.weightsMatrix = WU.buildTextWeightDict(
weightsFile, self.ssdo.master2Order)
else:
#### If No Weightsfile Provided, Use 8 Nearest Neighbors ####
if ssdo.numObs <= 9:
nn = ssdo.numObs - 2
ARCPY.AddIDMessage("WARNING", 1500, 8, nn)
else:
nn = 8
self.weightsType = "GA"
gaSearch = GAPY.ga_nsearch(self.ssdo.gaTable)
gaSearch.init_nearest(0.0, nn, "euclidean")
self.weightsMatrix = gaSearch
#### Initialize Data ####
self.runModels()
def __init__(self, ssdo, dependentVar, independentVars, weightsFile,
outputReportFile = None, outputTable = None,
maxIndVars = 5, minIndVars = 1, minR2 = .5,
maxCoef = .01, maxVIF = 5.0, minJB = .1, minMI = .1):
ARCPY.env.overwriteOutput = True
#### Set Initial Attributes ####
UTILS.assignClassAttr(self, locals())
self.masterField = self.ssdo.masterField
self.warnedTProb = False
#### Set Boolean For Passing All Moran's I ####
self.allMIPass = UTILS.compareFloat(0.0, self.minMI, rTol = .00000001)
#### Assess Whether SWM File Being Used ####
if weightsFile:
weightSuffix = weightsFile.split(".")[-1].lower()
if weightSuffix == "swm":
self.weightsType = "SWM"
self.weightsMatrix = self.weightsFile
else:
self.weightsType = "GWT"
self.weightsMatrix = WU.buildTextWeightDict(weightsFile,
self.ssdo.master2Order)
else:
#### If No Weightsfile Provided, Use 8 Nearest Neighbors ####
if ssdo.numObs <= 9:
nn = ssdo.numObs - 2
ARCPY.AddIDMessage("WARNING", 1500, 8, nn)
else:
nn = 8
self.weightsType = "GA"
gaSearch = GAPY.ga_nsearch(self.ssdo.gaTable)
gaSearch.init_nearest(0.0, nn, "euclidean")
self.weightsMatrix = gaSearch
#### Initialize Data ####
self.runModels()
def construct(self):
"""Constructs the neighborhood structure for each feature and
dispatches the appropriate values for the calculation of the
statistic."""
#### Shorthand Attributes ####
ssdo = self.ssdo
varName = self.varName
concept = self.concept
gaConcept = concept.lower()
threshold = self.threshold
exponent = self.exponent
wType = self.wType
rowStandard = self.rowStandard
numObs = self.numObs
master2Order = self.master2Order
masterField = ssdo.masterField
weightsFile = self.weightsFile
#### Assure that Variance is Larger than Zero ####
yVar = NUM.var(self.y)
if NUM.isnan(yVar) or yVar <= 0.0:
ARCPY.AddIDMessage("Error", 906)
raise SystemExit()
#### Create Deviation Variables ####
self.yBar = NUM.mean(self.y)
self.yDev = self.y - self.yBar
#### Create Base Data Structures/Variables ####
self.numer = 0.0
self.denom = NUM.sum(self.yDev**2.0)
self.rowSum = NUM.zeros(numObs)
self.colSum = NUM.zeros(numObs)
self.s0 = 0
self.s1 = 0
self.wij = {}
#### Set Neighborhood Structure Type ####
if self.weightsFile:
if self.swmFileBool:
#### Open Spatial Weights and Obtain Chars ####
swm = WU.SWMReader(weightsFile)
N = swm.numObs
rowStandard = swm.rowStandard
#### Check to Assure Complete Set of Weights ####
if numObs > N:
ARCPY.AddIDMessage("Error", 842, numObs, N)
raise SystemExit()
#### Check if Selection Set ####
isSubSet = False
if numObs < N:
isSubSet = True
iterVals = xrange(N)
else:
#### Warning for GWT with Bad Records/Selection ####
if ssdo.selectionSet or ssdo.badRecords:
ARCPY.AddIDMessage("WARNING", 1029)
#### Build Weights Dictionary ####
weightDict = WU.buildTextWeightDict(weightsFile, master2Order)
iterVals = master2Order.keys()
N = numObs
elif wType in [4, 5]:
#### Polygon Contiguity ####
if wType == 4:
contiguityType = "ROOK"
else:
contiguityType = "QUEEN"
contDict = WU.polygonNeighborDict(ssdo.inputFC, ssdo.oidName,
contiguityType = contiguityType)
iterVals = master2Order.keys()
N = numObs
else:
gaTable = ssdo.gaTable
gaSearch = GAPY.ga_nsearch(gaTable)
if wType == 7:
#### Zone of Indiff, All Related to All ####
gaSearch.init_nearest(threshold, numObs, gaConcept)
else:
#### Inverse and Fixed Distances ####
gaSearch.init_nearest(threshold, 0, gaConcept)
iterVals = range(numObs)
N = numObs
neighWeights = ARC._ss.NeighborWeights(gaTable, gaSearch,
weight_type = wType,
exponent = exponent,
row_standard = rowStandard)
#### Create Progressor ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84007), 0, N, 1)
#### Create Neighbor Info Class ####
ni = WU.NeighborInfo(masterField)
#### Calculation For Each Feature ####
for i in iterVals:
if self.swmFileBool:
#### Using SWM File ####
info = swm.swm.readEntry()
masterID = info[0]
if master2Order.has_key(masterID):
rowInfo = WU.getWeightsValuesSWM(info, master2Order,
self.yDev,
rowStandard = rowStandard,
isSubSet = isSubSet)
includeIt = True
else:
includeIt = False
elif self.weightsFile and not self.swmFileBool:
#### Text Weights ####
masterID = i
includeIt = True
rowInfo = WU.getWeightsValuesText(masterID, master2Order,
weightDict, self.yDev)
elif wType in [4, 5]:
#### Polygon Contiguity ####
masterID = i
includeIt = True
rowInfo = WU.getWeightsValuesCont(masterID, master2Order,
contDict, self.yDev,
rowStandard = rowStandard)
else:
#### Distance Based ####
masterID = gaTable[i][0]
includeIt = True
rowInfo = WU.getWeightsValuesOTF(neighWeights, i, self.yDev)
#### Subset Boolean for SWM File ####
if includeIt:
#### Parse Row Info ####
orderID, yiDev, nhIDs, nhVals, weights = rowInfo
#### Assure Neighbors Exist After Selection ####
nn, nhIDs, nhVals, weights = ni.processInfo(masterID, nhIDs,
nhVals, weights)
if nn:
#### Process Feature Contribution to Moran's I ####
self.processRow(orderID, yiDev, nhIDs,
nhVals, weights)
#### Reset Progessor ####
ARCPY.SetProgressorPosition()
#### Clean Up ####
if self.swmFileBool:
swm.close()
#### Report on Features with No Neighbors ####
ni.reportNoNeighbors()
#### Report on Features with Large Number of Neighbors ####
ni.reportWarnings()
ni.reportMaximums()
self.neighInfo = ni
def collectEvents(ssdo, outputFC):
"""This utility converts event data into weighted point data by
dissolving all coincident points into unique points with a new count
field that contains the number of original features at that
location.
INPUTS:
inputFC (str): path to the input feature class
outputFC (str): path to the input feature class
"""
#### Set Default Progressor for Neigborhood Structure ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84143))
#### Validate Output Workspace ####
ERROR.checkOutputPath(outputFC)
#### True Centroid Warning For Non-Point FCs ####
if ssdo.shapeType.upper() != "POINT":
ARCPY.AddIDMessage("WARNING", 1021)
#### Create GA Data Structure ####
gaTable, gaInfo = WU.gaTable(ssdo.inputFC, spatRef = ssdo.spatialRefString)
#### Assure Enough Observations ####
cnt = UTILS.getCount(ssdo.inputFC)
ERROR.errorNumberOfObs(cnt, minNumObs = 4)
N = gaInfo[0]
ERROR.errorNumberOfObs(N, minNumObs = 4)
#### Process Any Bad Records Encountered ####
numBadRecs = cnt - N
if numBadRecs:
badRecs = WU.parseGAWarnings(gaTable.warnings)
if not ssdo.silentWarnings:
ERROR.reportBadRecords(cnt, numBadRecs, badRecs,
label = ssdo.oidName)
#### Create k-Nearest Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaSearch.init_nearest(0.0, 0, "euclidean")
#### Create Output Feature Class ####
outPath, outName = OS.path.split(outputFC)
try:
DM.CreateFeatureclass(outPath, outName, "POINT", "", ssdo.mFlag,
ssdo.zFlag, ssdo.spatialRefString)
except:
ARCPY.AddIDMessage("ERROR", 210, outputFC)
raise SystemExit()
#### Add Count Field ####
countFieldNameOut = ARCPY.ValidateFieldName(countFieldName, outPath)
UTILS.addEmptyField(outputFC, countFieldNameOut, "LONG")
fieldList = ["SHAPE@", countFieldNameOut]
#### Set Insert Cursor ####
rowsOut = DA.InsertCursor(outputFC, fieldList)
#### Set Progressor for Calculation ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84007), 0, N, 1)
#### ID List to Search ####
rowsIN = range(N)
maxCount = 0
numUnique = 0
for row in rowsIN:
#### Get Row Coords ####
rowInfo = gaTable[row]
x0, y0 = rowInfo[1]
count = 1
#### Search For Exact Coord Match ####
gaSearch.search_by_idx(row)
for nh in gaSearch:
count += 1
rowsIN.remove(nh.idx)
ARCPY.SetProgressorPosition()
#### Keep Track of Max Count ####
maxCount = max([count, maxCount])
#### Create Output Point ####
pnt = (x0, y0, ssdo.defaultZ)
#### Create and Populate New Feature ####
rowResult = [pnt, count]
rowsOut.insertRow(rowResult)
numUnique += 1
ARCPY.SetProgressorPosition()
#### Clean Up ####
del rowsOut, gaTable
return countFieldNameOut, maxCount, N, numUnique
def collectEvents(ssdo, outputFC):
"""This utility converts event data into weighted point data by
dissolving all coincident points into unique points with a new count
field that contains the number of original features at that
location.
INPUTS:
inputFC (str): path to the input feature class
outputFC (str): path to the input feature class
"""
#### Set Default Progressor for Neigborhood Structure ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84143))
#### Validate Output Workspace ####
ERROR.checkOutputPath(outputFC)
#### True Centroid Warning For Non-Point FCs ####
if ssdo.shapeType.upper() != "POINT":
ARCPY.AddIDMessage("WARNING", 1021)
#### Create GA Data Structure ####
gaTable, gaInfo = WU.gaTable(ssdo.inputFC, spatRef=ssdo.spatialRefString)
#### Assure Enough Observations ####
cnt = UTILS.getCount(ssdo.inputFC)
ERROR.errorNumberOfObs(cnt, minNumObs=4)
N = gaInfo[0]
ERROR.errorNumberOfObs(N, minNumObs=4)
#### Process Any Bad Records Encountered ####
numBadRecs = cnt - N
if numBadRecs:
badRecs = WU.parseGAWarnings(gaTable.warnings)
if not ssdo.silentWarnings:
ERROR.reportBadRecords(cnt,
numBadRecs,
badRecs,
label=ssdo.oidName)
#### Create k-Nearest Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaSearch.init_nearest(0.0, 0, "euclidean")
#### Create Output Feature Class ####
outPath, outName = OS.path.split(outputFC)
try:
DM.CreateFeatureclass(outPath, outName, "POINT", "", ssdo.mFlag,
ssdo.zFlag, ssdo.spatialRefString)
except:
ARCPY.AddIDMessage("ERROR", 210, outputFC)
raise SystemExit()
#### Add Count Field ####
countFieldNameOut = ARCPY.ValidateFieldName(countFieldName, outPath)
UTILS.addEmptyField(outputFC, countFieldNameOut, "LONG")
fieldList = ["SHAPE@", countFieldNameOut]
#### Set Insert Cursor ####
rowsOut = DA.InsertCursor(outputFC, fieldList)
#### Set Progressor for Calculation ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84007), 0, N, 1)
#### ID List to Search ####
rowsIN = range(N)
maxCount = 0
numUnique = 0
for row in rowsIN:
#### Get Row Coords ####
rowInfo = gaTable[row]
x0, y0 = rowInfo[1]
count = 1
#### Search For Exact Coord Match ####
gaSearch.search_by_idx(row)
for nh in gaSearch:
count += 1
rowsIN.remove(nh.idx)
ARCPY.SetProgressorPosition()
#### Keep Track of Max Count ####
maxCount = max([count, maxCount])
#### Create Output Point ####
pnt = (x0, y0, ssdo.defaultZ)
#### Create and Populate New Feature ####
rowResult = [pnt, count]
rowsOut.insertRow(rowResult)
numUnique += 1
ARCPY.SetProgressorPosition()
#### Clean Up ####
del rowsOut, gaTable
return countFieldNameOut, maxCount, N, numUnique
def construct(self):
"""Constructs the neighborhood structure for each feature and
dispatches the appropriate values for the calculation of the
statistic."""
#### Shorthand Attributes ####
ssdo = self.ssdo
varName = self.varName
concept = self.concept
gaConcept = concept.lower()
threshold = self.threshold
exponent = self.exponent
wType = self.wType
rowStandard = self.rowStandard
numObs = self.numObs
master2Order = self.master2Order
masterField = ssdo.masterField
weightsFile = self.weightsFile
#### Check That All Input Values are Positive ####
if NUM.sum(self.y < 0.0) != 0:
ARCPY.AddIDMessage("Error", 915)
raise SystemExit()
#### Assure that Variance is Larger than Zero ####
yVar = NUM.var(self.y)
if NUM.isnan(yVar) or yVar <= 0.0:
ARCPY.AddIDMessage("Error", 906)
raise SystemExit()
#### Create Base Data Structures/Variables ####
self.numer = 0.0
self.denom = 0.0
self.rowSum = NUM.zeros(numObs)
self.colSum = NUM.zeros(numObs)
self.ySum = 0.0
self.y2Sum = 0.0
self.y3Sum = 0.0
self.y4Sum = 0.0
self.s0 = 0
self.s1 = 0
self.wij = {}
#### Set Neighborhood Structure Type ####
if self.weightsFile:
if self.swmFileBool:
#### Open Spatial Weights and Obtain Chars ####
swm = WU.SWMReader(weightsFile)
N = swm.numObs
rowStandard = swm.rowStandard
#### Check to Assure Complete Set of Weights ####
if numObs > N:
ARCPY.AddIDMessage("Error", 842, numObs, N)
raise SystemExit()
#### Check if Selection Set ####
isSubSet = False
if numObs < N:
isSubSet = True
iterVals = xrange(N)
else:
#### Warning for GWT with Bad Records/Selection ####
if ssdo.selectionSet or ssdo.badRecords:
ARCPY.AddIDMessage("WARNING", 1029)
#### Build Weights Dictionary ####
weightDict = WU.buildTextWeightDict(weightsFile, master2Order)
iterVals = master2Order.iterkeys()
N = numObs
elif wType in [4, 5]:
#### Polygon Contiguity ####
if wType == 4:
contiguityType = "ROOK"
else:
contiguityType = "QUEEN"
contDict = WU.polygonNeighborDict(ssdo.inputFC, ssdo.oidName,
contiguityType = contiguityType)
iterVals = master2Order.keys()
N = numObs
else:
gaTable = ssdo.gaTable
gaSearch = GAPY.ga_nsearch(gaTable)
if wType == 7:
#### Zone of Indiff, All Related to All ####
gaSearch.init_nearest(threshold, numObs, gaConcept)
else:
#### Inverse and Fixed Distances ####
gaSearch.init_nearest(threshold, 0, gaConcept)
iterVals = xrange(numObs)
N = numObs
neighWeights = ARC._ss.NeighborWeights(gaTable, gaSearch,
weight_type = wType,
exponent = exponent,
row_standard = rowStandard)
#### Create Progressor ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84007), 0, N, 1)
#### Create Neighbor Info Class ####
ni = WU.NeighborInfo(masterField)
#### Calculation For Each Feature ####
for i in iterVals:
if self.swmFileBool:
#### Using SWM File ####
info = swm.swm.readEntry()
masterID = info[0]
if master2Order.has_key(masterID):
rowInfo = WU.getWeightsValuesSWM(info, master2Order,
self.y,
rowStandard = rowStandard,
isSubSet = isSubSet)
includeIt = True
else:
includeIt = False
elif self.weightsFile and not self.swmFileBool:
#### Text Weights ####
masterID = i
includeIt = True
rowInfo = WU.getWeightsValuesText(masterID, master2Order,
weightDict, self.y)
elif wType in [4, 5]:
#### Polygon Contiguity ####
masterID = i
includeIt = True
rowInfo = WU.getWeightsValuesCont(masterID, master2Order,
contDict, self.y,
rowStandard = rowStandard)
else:
#### Distance Based ####
masterID = gaTable[i][0]
includeIt = True
rowInfo = WU.getWeightsValuesOTF(neighWeights, i, self.y)
#### Subset Boolean for SWM File ####
if includeIt:
#### Parse Row Info ####
orderID, yiVal, nhIDs, nhVals, weights = rowInfo
#### Assure Neighbors Exist After Selection ####
nn, nhIDs, nhVals, weights = ni.processInfo(masterID, nhIDs,
nhVals, weights)
if nn:
#### Process Feature Contribution to General G ####
self.processRow(orderID, yiVal, nhIDs,
nhVals, weights)
#### Reset Progessor ####
ARCPY.SetProgressorPosition()
#### Clean Up ####
if self.swmFileBool:
swm.close()
#### Report on Features with No Neighbors ####
ni.reportNoNeighbors()
#### Report on Features with Large Number of Neighbors ####
ni.reportWarnings()
ni.reportMaximums()
self.neighInfo = ni
def unweightedCalc(self):
"""Performs unweighted k-function."""
#### Attribute Shortcuts ####
ssdo = self.ssdo
reduce = self.reduce
simulate = self.simulate
ripley = self.ripley
if reduce:
studyArea2Use = self.reduceArea
else:
studyArea2Use = self.studyArea
self.ld = COLL.defaultdict(float)
if self.permutations:
self.ldMin = COLL.defaultdict(float)
self.ldMax = COLL.defaultdict(float)
for order in self.cutoffOrder:
self.ldMin[order] = 99999999999.
permsPlus = self.permutations + 1
for perm in xrange(0, permsPlus):
#### Permutation Progressor ####
pmsg = ARCPY.GetIDMessage(84184)
progressMessage = pmsg.format(perm, permsPlus)
ARCPY.SetProgressor("default", progressMessage)
#### Permutate the XY ####
if perm != 0:
self.permutateTable()
gaSearch = GAPY.ga_nsearch(self.kTable)
gaSearch.init_nearest(self.stepMax, 0, "euclidean")
N = len(self.kTable)
numIDs = len(self.ids)
kij = COLL.defaultdict(float)
for i in xrange(N):
row = self.kTable[i]
id0 = row[0]
if id0 in self.ids:
x0,y0 = row[1]
gaSearch.search_by_idx(i)
for nh in gaSearch:
neighInfo = self.kTable[nh.idx]
nhID = neighInfo[0]
x1,y1 = neighInfo[1]
dist = WU.euclideanDistance(x0,x1,y0,y1)
if ripley:
value = self.returnRipley(id0, dist)
else:
value = 1.0
for order in self.reverseOrder:
cutoff = self.cutoffs[order]
if dist > cutoff:
break
kij[order] += value
ARCPY.SetProgressorPosition()
#### Calculate Stats USing Dictionaries ####
weightSumVal = numIDs * (numIDs - 1.0)
denom = NUM.pi * weightSumVal
for order in self.cutoffOrder:
res = kij[order]
numer = res * studyArea2Use
permResult = NUM.sqrt( (numer/denom) )
if perm:
self.ldMin[order] = min(self.ldMin[order],
permResult)
self.ldMax[order] = max(self.ldMax[order],
permResult)
else:
self.ld[order] = permResult
def distance2SWM(inputFC, swmFile, masterField, fixed = 0,
concept = "EUCLIDEAN", exponent = 1.0, threshold = None,
kNeighs = 1, rowStandard = True):
"""Creates a sparse spatial weights matrix (SWM) based on k-nearest
neighbors.
INPUTS:
inputFC (str): path to the input feature class
swmFile (str): path to the SWM file.
masterField (str): field in table that serves as the mapping.
fixed (boolean): fixed (1) or inverse (0) distance?
concept: {str, EUCLIDEAN}: EUCLIDEAN or MANHATTAN
exponent {float, 1.0}: distance decay
threshold {float, None}: distance threshold
kNeighs (int): number of neighbors to return
rowStandard {bool, True}: row standardize weights?
"""
#### Create SSDataObject ####
ssdo = SSDO.SSDataObject(inputFC, templateFC = inputFC,
useChordal = True)
#### Validation of Master Field ####
verifyMaster = ERROR.checkField(ssdo.allFields, masterField, types = [0,1])
#### Read Data ####
ssdo.obtainDataGA(masterField, minNumObs = 2)
N = ssdo.numObs
gaTable = ssdo.gaTable
if fixed:
wType = 1
else:
wType = 0
#### Set Default Progressor for Neigborhood Structure ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84143))
#### Set the Distance Threshold ####
concept, gaConcept = WU.validateDistanceMethod(concept, ssdo.spatialRef)
if threshold == None:
threshold, avgDist = WU.createThresholdDist(ssdo,
concept = concept)
#### Assures that the Threshold is Appropriate ####
gaExtent = UTILS.get92Extent(ssdo.extent)
threshold, maxSet = WU.checkDistanceThreshold(ssdo, threshold,
weightType = wType)
#### If the Threshold is Set to the Max ####
#### Set to Zero for Script Logic ####
if maxSet:
#### All Locations are Related ####
threshold = SYS.maxint
if N > 500:
ARCPY.AddIDMessage("Warning", 717)
#### Assure k-Nearest is Less Than Number of Features ####
if kNeighs >= N and fixed:
ARCPY.AddIDMessage("ERROR", 975)
raise SystemExit()
#### Create Distance/k-Nearest Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaSearch.init_nearest(threshold, kNeighs, gaConcept)
neighWeights = ARC._ss.NeighborWeights(gaTable, gaSearch,
weight_type = wType,
exponent = exponent,
row_standard = False)
#### Set Progressor for Weights Writing ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84127), 0, N, 1)
#### Initialize Spatial Weights Matrix File ####
swmWriter = WU.SWMWriter(swmFile, masterField, ssdo.spatialRefName,
N, rowStandard, inputFC = inputFC,
wType = wType, distanceMethod = concept,
exponent = exponent, threshold = threshold)
#### Unique Master ID Dictionary ####
masterDict = {}
#### Unique Master ID Dictionary ####
masterSet = set([])
for row in xrange(N):
masterID = int(gaTable[row][2])
if masterID in masterSet:
ARCPY.AddIDMessage("Error", 644, masterField)
ARCPY.AddIDMessage("Error", 643)
raise SystemExit()
else:
masterSet.add(masterID)
neighs, weights = neighWeights[row]
neighs = [ gaTable[nh][2] for nh in neighs ]
#### Add Spatial Weights Matrix Entry ####
swmWriter.swm.writeEntry(masterID, neighs, weights)
#### Set Progress ####
ARCPY.SetProgressorPosition()
swmWriter.close()
del gaTable
#### Report Warning/Max Neighbors ####
swmWriter.reportNeighInfo()
#### Add Linear/Angular Unit (Distance Based Only) ####
distanceOut = ssdo.distanceInfo.outputString
distanceOut = [ARCPY.GetIDMessage(84344).format(distanceOut)]
#### Report Spatial Weights Summary ####
swmWriter.report(additionalInfo = distanceOut)
#### Report SWM File is Large ####
swmWriter.reportLargeSWM()
def delaunay2SWM(inputFC, swmFile, masterField, rowStandard = True):
"""Creates a sparse spatial weights matrix (SWM) based on Delaunay
Triangulation.
INPUTS:
inputFC (str): path to the input feature class
swmFile (str): path to the SWM file.
masterField (str): field in table that serves as the mapping.
rowStandard {bool, True}: row standardize weights?
"""
#### Set Default Progressor for Neigborhood Structure ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84143))
#### Create SSDataObject ####
ssdo = SSDO.SSDataObject(inputFC, templateFC = inputFC,
useChordal = True)
cnt = UTILS.getCount(inputFC)
ERROR.errorNumberOfObs(cnt, minNumObs = 2)
#### Validation of Master Field ####
verifyMaster = ERROR.checkField(ssdo.allFields, masterField, types = [0,1])
#### Create GA Data Structure ####
gaTable, gaInfo = WU.gaTable(ssdo.catPath, [masterField],
spatRef = ssdo.spatialRefString)
#### Assure Enough Observations ####
N = gaInfo[0]
ERROR.errorNumberOfObs(N, minNumObs = 2)
#### Process any bad records encountered ####
numBadRecs = cnt - N
if numBadRecs:
badRecs = WU.parseGAWarnings(gaTable.warnings)
err = ERROR.reportBadRecords(cnt, numBadRecs, badRecs,
label = ssdo.oidName)
#### Create Delaunay Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaSearch.init_delaunay()
neighWeights = ARC._ss.NeighborWeights(gaTable, gaSearch,
weight_type = 1,
row_standard = False)
#### Set Progressor for Weights Writing ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84127), 0, N, 1)
#### Initialize Spatial Weights Matrix File ####
swmWriter = WU.SWMWriter(swmFile, masterField, ssdo.spatialRefName,
N, rowStandard, inputFC = inputFC,
wType = 3)
#### Unique Master ID Dictionary ####
masterSet = set([])
for row in xrange(N):
masterID = int(gaTable[row][2])
if masterID in masterSet:
ARCPY.AddIDMessage("Error", 644, masterField)
ARCPY.AddIDMessage("Error", 643)
raise SystemExit()
else:
masterSet.add(masterID)
neighs, weights = neighWeights[row]
neighs = [ gaTable[nh][2] for nh in neighs ]
#### Add Spatial Weights Matrix Entry ####
swmWriter.swm.writeEntry(masterID, neighs, weights)
#### Set Progress ####
ARCPY.SetProgressorPosition()
#### Clean Up ####
swmWriter.close()
del gaTable
#### Report if Any Features Have No Neighbors ####
swmWriter.reportNoNeighbors()
#### Report Spatial Weights Summary ####
swmWriter.report()
#### Report SWM File is Large ####
swmWriter.reportLargeSWM()
def distance2SWM(inputFC, swmFile, masterField, fixed = 0,
concept = "EUCLIDEAN", exponent = 1.0, threshold = None,
kNeighs = 1, rowStandard = True):
"""Creates a sparse spatial weights matrix (SWM) based on k-nearest
neighbors.
INPUTS:
inputFC (str): path to the input feature class
swmFile (str): path to the SWM file.
masterField (str): field in table that serves as the mapping.
fixed (boolean): fixed (1) or inverse (0) distance?
concept: {str, EUCLIDEAN}: EUCLIDEAN or MANHATTAN
exponent {float, 1.0}: distance decay
threshold {float, None}: distance threshold
kNeighs (int): number of neighbors to return
rowStandard {bool, True}: row standardize weights?
"""
#### Create SSDataObject ####
ssdo = SSDO.SSDataObject(inputFC, templateFC = inputFC,
useChordal = True)
#### Validation of Master Field ####
verifyMaster = ERROR.checkField(ssdo.allFields, masterField, types = [0,1])
#### Read Data ####
ssdo.obtainDataGA(masterField, minNumObs = 2)
N = ssdo.numObs
gaTable = ssdo.gaTable
if fixed:
wType = 1
else:
wType = 0
#### Set Default Progressor for Neigborhood Structure ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84143))
#### Set the Distance Threshold ####
concept, gaConcept = WU.validateDistanceMethod(concept, ssdo.spatialRef)
if threshold == None:
threshold, avgDist = WU.createThresholdDist(ssdo,
concept = concept)
#### Assures that the Threshold is Appropriate ####
gaExtent = UTILS.get92Extent(ssdo.extent)
threshold, maxSet = WU.checkDistanceThreshold(ssdo, threshold,
weightType = wType)
#### If the Threshold is Set to the Max ####
#### Set to Zero for Script Logic ####
if maxSet:
#### All Locations are Related ####
threshold = SYS.maxint
if N > 500:
ARCPY.AddIDMessage("Warning", 717)
#### Assure k-Nearest is Less Than Number of Features ####
if kNeighs >= N and fixed:
ARCPY.AddIDMessage("ERROR", 975)
raise SystemExit()
#### Create Distance/k-Nearest Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaSearch.init_nearest(threshold, kNeighs, gaConcept)
neighWeights = ARC._ss.NeighborWeights(gaTable, gaSearch,
weight_type = wType,
exponent = exponent,
row_standard = False)
#### Set Progressor for Weights Writing ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84127), 0, N, 1)
#### Initialize Spatial Weights Matrix File ####
swmWriter = WU.SWMWriter(swmFile, masterField, ssdo.spatialRefName,
N, rowStandard, inputFC = inputFC,
wType = wType, distanceMethod = concept,
exponent = exponent, threshold = threshold)
#### Unique Master ID Dictionary ####
masterDict = {}
#### Unique Master ID Dictionary ####
masterSet = set([])
for row in xrange(N):
masterID = int(gaTable[row][2])
if masterID in masterSet:
ARCPY.AddIDMessage("Error", 644, masterField)
ARCPY.AddIDMessage("Error", 643)
raise SystemExit()
else:
masterSet.add(masterID)
neighs, weights = neighWeights[row]
neighs = [ gaTable[nh][2] for nh in neighs ]
#### Add Spatial Weights Matrix Entry ####
swmWriter.swm.writeEntry(masterID, neighs, weights)
#### Set Progress ####
ARCPY.SetProgressorPosition()
swmWriter.close()
del gaTable
#### Report Warning/Max Neighbors ####
swmWriter.reportNeighInfo()
#### Add Linear/Angular Unit (Distance Based Only) ####
distanceOut = ssdo.distanceInfo.outputString
distanceOut = [ARCPY.GetIDMessage(84344).format(distanceOut)]
#### Report Spatial Weights Summary ####
swmWriter.report(additionalInfo = distanceOut)
#### Report SWM File is Large ####
swmWriter.reportLargeSWM()
def spaceTime2SWM(inputFC, swmFile, masterField, concept = "EUCLIDEAN",
threshold = None, rowStandard = True,
timeField = None, timeType = None,
timeValue = None):
"""
inputFC (str): path to the input feature class
swmFile (str): path to the SWM file.
masterField (str): field in table that serves as the mapping.
concept: {str, EUCLIDEAN}: EUCLIDEAN or MANHATTAN
threshold {float, None}: distance threshold
rowStandard {bool, True}: row standardize weights?
timeField {str, None}: name of the date-time field
timeType {str, None}: ESRI enumeration of date-time intervals
timeValue {float, None}: value forward and backward in time
"""
#### Assure Temporal Parameters are Set ####
if not timeField:
ARCPY.AddIDMessage("ERROR", 1320)
raise SystemExit()
if not timeType:
ARCPY.AddIDMessage("ERROR", 1321)
raise SystemExit()
if not timeValue or timeValue <= 0:
ARCPY.AddIDMessage("ERROR", 1322)
raise SystemExit()
#### Create SSDataObject ####
ssdo = SSDO.SSDataObject(inputFC, templateFC = inputFC,
useChordal = True)
cnt = UTILS.getCount(inputFC)
ERROR.errorNumberOfObs(cnt, minNumObs = 2)
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84001), 0, cnt, 1)
#### Validation of Master Field ####
verifyMaster = ERROR.checkField(ssdo.allFields, masterField, types = [0,1])
badIDs = []
#### Create Temporal Hash ####
timeInfo = {}
xyCoords = NUM.empty((cnt, 2), float)
#### Process Field Values ####
fieldList = [masterField, "SHAPE@XY", timeField]
try:
rows = DA.SearchCursor(ssdo.catPath, fieldList, "",
ssdo.spatialRefString)
except:
ARCPY.AddIDMessage("ERROR", 204)
raise SystemExit()
#### Add Data to GATable and Time Dictionary ####
c = 0
for row in rows:
badRow = False
#### Assure Masterfield is Valid ####
masterID = row[0]
if masterID == None or masterID == "":
badRow = True
#### Assure Date/Time is Valid ####
timeStamp = row[-1]
if timeStamp == None or timeStamp == "":
badRow = True
#### Assure Centroid is Valid ####
badXY = row[1].count(None)
if not badXY:
x,y = row[1]
xyCoords[c] = (x,y)
else:
badRow = True
#### Process Data ####
if not badRow:
if timeInfo.has_key(masterID):
#### Assure Uniqueness ####
ARCPY.AddIDMessage("Error", 644, masterField)
ARCPY.AddIDMessage("Error", 643)
raise SystemExit()
else:
#### Fill Date/Time Dict ####
startDT, endDT = TUTILS.calculateTimeWindow(timeStamp,
timeValue,
timeType)
timeInfo[masterID] = (timeStamp, startDT, endDT)
else:
badIDs.append(masterID)
#### Set Progress ####
c += 1
ARCPY.SetProgressorPosition()
#### Clean Up ####
del rows
#### Get Set of Bad IDs ####
numBadObs = len(badIDs)
badIDs = list(set(badIDs))
badIDs.sort()
badIDs = [ str(i) for i in badIDs ]
#### Process any bad records encountered ####
if numBadObs:
ERROR.reportBadRecords(cnt, numBadObs, badIDs, label = masterField)
#### Load Neighbor Table ####
gaTable, gaInfo = WU.gaTable(ssdo.inputFC,
fieldNames = [masterField, timeField],
spatRef = ssdo.spatialRefString)
numObs = len(gaTable)
xyCoords = xyCoords[0:numObs]
#### Set the Distance Threshold ####
concept, gaConcept = WU.validateDistanceMethod(concept, ssdo.spatialRef)
if threshold == None:
#### Set Progressor for Search ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84144))
#### Create k-Nearest Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaSearch.init_nearest(0.0, 1, gaConcept)
neighDist = ARC._ss.NeighborDistances(gaTable, gaSearch)
N = len(neighDist)
threshold = 0.0
sumDist = 0.0
#### Find Maximum Nearest Neighbor Distance ####
for row in xrange(N):
dij = neighDist[row][-1][0]
if dij > threshold:
threshold = dij
sumDist += dij
ARCPY.SetProgressorPosition()
#### Increase For Rounding Error ####
threshold = threshold * 1.0001
avgDist = sumDist / (N * 1.0)
#### Add Linear/Angular Units ####
thresholdStr = ssdo.distanceInfo.printDistance(threshold)
ARCPY.AddIDMessage("Warning", 853, thresholdStr)
#### Chordal Default Check ####
if ssdo.useChordal:
hardMaxExtent = ARC._ss.get_max_gcs_distance(ssdo.spatialRef)
if threshold > hardMaxExtent:
ARCPY.AddIDMessage("ERROR", 1609)
raise SystemExit()
#### Clean Up ####
del gaSearch
#### Create Missing SSDO Info ####
extent = UTILS.resetExtent(xyCoords)
#### Reset Coordinates for Chordal ####
if ssdo.useChordal:
sliceInfo = UTILS.SpheroidSlice(extent, ssdo.spatialRef)
maxExtent = sliceInfo.maxExtent
else:
env = UTILS.Envelope(extent)
maxExtent = env.maxExtent
threshold = checkDistanceThresholdSWM(ssdo, threshold, maxExtent)
#### Set Default Progressor for Neigborhood Structure ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84143))
#### Create Distance Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaSearch.init_nearest(threshold, 0, gaConcept)
neighSearch = ARC._ss.NeighborSearch(gaTable, gaSearch)
#### Set Progressor for Weights Writing ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84127), 0, numObs, 1)
#### Initialize Spatial Weights Matrix File ####
swmWriter = WU.SWMWriter(swmFile, masterField, ssdo.spatialRefName,
numObs, rowStandard, inputFC = inputFC,
wType = 9, distanceMethod = concept,
threshold = threshold, timeField = timeField,
timeType = timeType, timeValue = timeValue)
for row in xrange(numObs):
masterID = gaTable[row][2]
#### Get Date/Time Info ####
dt0, startDT0, endDT0 = timeInfo[masterID]
nhs = neighSearch[row]
neighs = []
weights = []
for nh in nhs:
#### Search Through Spatial Neighbors ####
neighID = gaTable[nh][2]
#### Get Date/Time Info ####
dt1, startDT1, endDT1 = timeInfo[neighID]
#### Filter Based on Date/Time ####
insideTimeWindow = TUTILS.isTimeNeighbor(startDT0, endDT0, dt1)
if insideTimeWindow:
neighs.append(neighID)
weights.append(1.0)
#### Add Spatial Weights Matrix Entry ####
swmWriter.swm.writeEntry(masterID, neighs, weights)
#### Set Progress ####
ARCPY.SetProgressorPosition()
swmWriter.close()
del gaTable
#### Report Warning/Max Neighbors ####
swmWriter.reportNeighInfo()
#### Report Spatial Weights Summary ####
swmWriter.report()
#### Report SWM File is Large ####
swmWriter.reportLargeSWM()
def kNearest2SWM(inputFC, swmFile, masterField, concept = "EUCLIDEAN",
kNeighs = 1, rowStandard = True):
"""Creates a sparse spatial weights matrix (SWM) based on k-nearest
neighbors.
INPUTS:
inputFC (str): path to the input feature class
swmFile (str): path to the SWM file.
masterField (str): field in table that serves as the mapping.
concept: {str, EUCLIDEAN}: EUCLIDEAN or MANHATTAN
kNeighs {int, 1}: number of neighbors to return
rowStandard {bool, True}: row standardize weights?
"""
#### Assure that kNeighs is Non-Zero ####
if kNeighs <= 0:
ARCPY.AddIDMessage("ERROR", 976)
raise SystemExit()
#### Set Default Progressor for Neigborhood Structure ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84143))
#### Create SSDataObject ####
ssdo = SSDO.SSDataObject(inputFC, templateFC = inputFC,
useChordal = True)
cnt = UTILS.getCount(inputFC)
ERROR.errorNumberOfObs(cnt, minNumObs = 2)
#### Validation of Master Field ####
verifyMaster = ERROR.checkField(ssdo.allFields, masterField, types = [0,1])
#### Create GA Data Structure ####
gaTable, gaInfo = WU.gaTable(ssdo.catPath, [masterField],
spatRef = ssdo.spatialRefString)
#### Assure Enough Observations ####
N = gaInfo[0]
ERROR.errorNumberOfObs(N, minNumObs = 2)
#### Process any bad records encountered ####
numBadRecs = cnt - N
if numBadRecs:
badRecs = WU.parseGAWarnings(gaTable.warnings)
err = ERROR.reportBadRecords(cnt, numBadRecs, badRecs,
label = ssdo.oidName)
#### Assure k-Nearest is Less Than Number of Features ####
if kNeighs >= N:
ARCPY.AddIDMessage("ERROR", 975)
raise SystemExit()
#### Create k-Nearest Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
concept, gaConcept = WU.validateDistanceMethod(concept, ssdo.spatialRef)
gaSearch.init_nearest(0.0, kNeighs, gaConcept)
neighWeights = ARC._ss.NeighborWeights(gaTable, gaSearch,
weight_type = 1,
row_standard = False)
#### Set Progressor for Weights Writing ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84127), 0, N, 1)
#### Initialize Spatial Weights Matrix File ####
swmWriter = WU.SWMWriter(swmFile, masterField, ssdo.spatialRefName,
N, rowStandard, inputFC = inputFC,
wType = 2, distanceMethod = concept,
numNeighs = kNeighs)
#### Unique Master ID Dictionary ####
masterSet = set([])
for row in xrange(N):
masterID = int(gaTable[row][2])
if masterID in masterSet:
ARCPY.AddIDMessage("Error", 644, masterField)
ARCPY.AddIDMessage("Error", 643)
raise SystemExit()
else:
masterSet.add(masterID)
neighs, weights = neighWeights[row]
neighs = [ gaTable[nh][2] for nh in neighs ]
#### Add Spatial Weights Matrix Entry ####
swmWriter.swm.writeEntry(masterID, neighs, weights)
#### Set Progress ####
ARCPY.SetProgressorPosition()
swmWriter.close()
del gaTable
#### Report Warning/Max Neighbors ####
swmWriter.reportNeighInfo()
#### Report Spatial Weights Summary ####
swmWriter.report()
#### Report SWM File is Large ####
swmWriter.reportLargeSWM()
def delaunay2SWM(inputFC, swmFile, masterField, rowStandard = True):
"""Creates a sparse spatial weights matrix (SWM) based on Delaunay
Triangulation.
INPUTS:
inputFC (str): path to the input feature class
swmFile (str): path to the SWM file.
masterField (str): field in table that serves as the mapping.
rowStandard {bool, True}: row standardize weights?
"""
#### Set Default Progressor for Neigborhood Structure ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84143))
#### Create SSDataObject ####
ssdo = SSDO.SSDataObject(inputFC, templateFC = inputFC,
useChordal = True)
cnt = UTILS.getCount(inputFC)
ERROR.errorNumberOfObs(cnt, minNumObs = 2)
#### Validation of Master Field ####
verifyMaster = ERROR.checkField(ssdo.allFields, masterField, types = [0,1])
#### Create GA Data Structure ####
gaTable, gaInfo = WU.gaTable(ssdo.catPath, [masterField],
spatRef = ssdo.spatialRefString)
#### Assure Enough Observations ####
N = gaInfo[0]
ERROR.errorNumberOfObs(N, minNumObs = 2)
#### Process any bad records encountered ####
numBadRecs = cnt - N
if numBadRecs:
badRecs = WU.parseGAWarnings(gaTable.warnings)
err = ERROR.reportBadRecords(cnt, numBadRecs, badRecs,
label = ssdo.oidName)
#### Create Delaunay Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaSearch.init_delaunay()
neighWeights = ARC._ss.NeighborWeights(gaTable, gaSearch,
weight_type = 1,
row_standard = False)
#### Set Progressor for Weights Writing ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84127), 0, N, 1)
#### Initialize Spatial Weights Matrix File ####
swmWriter = WU.SWMWriter(swmFile, masterField, ssdo.spatialRefName,
N, rowStandard, inputFC = inputFC,
wType = 3)
#### Unique Master ID Dictionary ####
masterSet = set([])
for row in xrange(N):
masterID = int(gaTable[row][2])
if masterID in masterSet:
ARCPY.AddIDMessage("Error", 644, masterField)
ARCPY.AddIDMessage("Error", 643)
raise SystemExit()
else:
masterSet.add(masterID)
neighs, weights = neighWeights[row]
neighs = [ gaTable[nh][2] for nh in neighs ]
#### Add Spatial Weights Matrix Entry ####
swmWriter.swm.writeEntry(masterID, neighs, weights)
#### Set Progress ####
ARCPY.SetProgressorPosition()
#### Clean Up ####
swmWriter.close()
del gaTable
#### Report if Any Features Have No Neighbors ####
swmWriter.reportNoNeighbors()
#### Report Spatial Weights Summary ####
swmWriter.report()
#### Report SWM File is Large ####
swmWriter.reportLargeSWM()
def polygon2SWM(inputFC, swmFile, masterField,
concept = "EUCLIDEAN", kNeighs = 0,
rowStandard = True, contiguityType = "ROOK"):
"""Creates a sparse spatial weights matrix (SWM) based on polygon
contiguity.
INPUTS:
inputFC (str): path to the input feature class
swmFile (str): path to the SWM file.
masterField (str): field in table that serves as the mapping.
concept: {str, EUCLIDEAN}: EUCLIDEAN or MANHATTAN
kNeighs {int, 0}: number of neighbors to return (1)
rowStandard {bool, True}: row standardize weights?
contiguityType {str, Rook}: {Rook = Edges Only, Queen = Edges/Vertices}
NOTES:
(1) kNeighs is used if polygon is not contiguous. E.g. Islands
"""
#### Set Default Progressor for Neigborhood Structure ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84143))
#### Create SSDataObject ####
ssdo = SSDO.SSDataObject(inputFC, templateFC = inputFC,
useChordal = True)
cnt = UTILS.getCount(inputFC)
ERROR.errorNumberOfObs(cnt, minNumObs = 2)
#### Validation of Master Field ####
verifyMaster = ERROR.checkField(ssdo.allFields, masterField,
types = [0,1])
#### Create GA Data Structure ####
gaTable, gaInfo = WU.gaTable(ssdo.catPath, [masterField],
spatRef = ssdo.spatialRefString)
#### Assure Enough Observations ####
N = gaInfo[0]
ERROR.errorNumberOfObs(N, minNumObs = 2)
#### Assure k-Nearest is Less Than Number of Features ####
if kNeighs >= N:
ARCPY.AddIDMessage("ERROR", 975)
raise SystemExit()
#### Create Nearest Neighbor Search Type For Islands ####
gaSearch = GAPY.ga_nsearch(gaTable)
concept, gaConcept = WU.validateDistanceMethod(concept, ssdo.spatialRef)
gaSearch.init_nearest(0.0, kNeighs, gaConcept)
if kNeighs > 0:
forceNeighbor = True
neighWeights = ARC._ss.NeighborWeights(gaTable, gaSearch,
weight_type = 1,
row_standard = False)
else:
forceNeighbor = False
neighSearch = None
#### Create Polygon Neighbors ####
polyNeighborDict = WU.polygonNeighborDict(inputFC, masterField,
contiguityType = contiguityType)
#### Write Poly Neighbor List (Dict) ####
#### Set Progressor for SWM Writing ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84127), 0, N, 1)
#### Initialize Spatial Weights Matrix File ####
if contiguityType == "ROOK":
wType = 4
else:
wType = 5
swmWriter = WU.SWMWriter(swmFile, masterField, ssdo.spatialRefName,
N, rowStandard, inputFC = inputFC,
wType = wType, distanceMethod = concept,
numNeighs = kNeighs)
#### Keep Track of Polygons w/o Neighbors ####
islandPolys = []
#### Write Polygon Contiguity to SWM File ####
for row in xrange(N):
rowInfo = gaTable[row]
oid = rowInfo[0]
masterID = rowInfo[2]
neighs = polyNeighborDict[masterID]
if neighs:
weights = [ 1. for nh in neighs ]
isIsland = False
else:
isIsland = True
islandPolys.append(oid)
weights = []
#### Get Nearest Neighbor Based On Centroid Distance ####
if isIsland and forceNeighbor:
neighs, weights = neighWeights[row]
neighs = [ gaTable[nh][2] for nh in neighs ]
#### Add Weights Entry ####
swmWriter.swm.writeEntry(masterID, neighs, weights)
#### Set Progress ####
ARCPY.SetProgressorPosition()
#### Report on Features with No Neighbors ####
countIslands = len(islandPolys)
if countIslands:
islandPolys.sort()
if countIslands > 30:
islandPolys = islandPolys[0:30]
ERROR.warningNoNeighbors(N, countIslands, islandPolys, ssdo.oidName,
forceNeighbor = forceNeighbor,
contiguity = True)
#### Clean Up ####
swmWriter.close()
del gaTable
#### Report Spatial Weights Summary ####
swmWriter.report()
#### Report SWM File is Large ####
swmWriter.reportLargeSWM()
del polyNeighborDict
def construct(self):
"""Constructs the neighborhood structure for each feature and
dispatches the appropriate values for the calculation of the
statistic."""
#### Shorthand Attributes ####
ssdo = self.ssdo
varName = self.varName
concept = self.concept
gaConcept = concept.lower()
threshold = self.threshold
exponent = self.exponent
wType = self.wType
rowStandard = self.rowStandard
numObs = self.numObs
master2Order = self.master2Order
masterField = ssdo.masterField
weightsFile = self.weightsFile
#### Assure that Variance is Larger than Zero ####
yVar = NUM.var(self.y)
if NUM.isnan(yVar) or yVar <= 0.0:
ARCPY.AddIDMessage("Error", 906)
raise SystemExit()
#### Create Deviation Variables ####
self.yBar = NUM.mean(self.y)
self.yDev = self.y - self.yBar
self.nm1 = numObs - 1.
self.nm2 = numObs - 2.
self.nm12 = self.nm1 * self.nm2
yDev2 = self.yDev**2.0
yDev2Norm = yDev2 / self.nm1
self.yDev2NormSum = sum(yDev2Norm)
yDev4 = self.yDev**4.0
yDev4Norm = yDev4 / self.nm1
yDev4NormSum = sum(yDev4Norm)
self.b2i = yDev4NormSum / (self.yDev2NormSum**2.0)
#### Create Base Data Structures/Variables ####
self.li = NUM.zeros(numObs)
self.ei = NUM.zeros(numObs)
self.vi = NUM.zeros(numObs)
self.zi = NUM.zeros(numObs)
self.pVals = NUM.ones(numObs)
if self.permutations:
self.pseudoPVals = NUM.ones(numObs)
self.moranInfo = {}
#### Keep Track of Features with No Neighbors ####
self.idsNoNeighs = []
#### Set Neighborhood Structure Type ####
if self.weightsFile:
if self.swmFileBool:
#### Open Spatial Weights and Obtain Chars ####
swm = WU.SWMReader(weightsFile)
N = swm.numObs
rowStandard = swm.rowStandard
self.swm = swm
#### Check to Assure Complete Set of Weights ####
if numObs > N:
ARCPY.AddIDMessage("Error", 842, numObs, N)
raise SystemExit()
#### Check if Selection Set ####
isSubSet = False
if numObs < N:
isSubSet = True
iterVals = xrange(N)
else:
#### Warning for GWT with Bad Records/Selection ####
if ssdo.selectionSet or ssdo.badRecords:
ARCPY.AddIDMessage("WARNING", 1029)
#### Build Weights Dictionary ####
weightDict = WU.buildTextWeightDict(weightsFile, master2Order)
iterVals = master2Order.keys()
N = numObs
elif wType in [4, 5]:
#### Polygon Contiguity ####
if wType == 4:
contiguityType = "ROOK"
else:
contiguityType = "QUEEN"
contDict = WU.polygonNeighborDict(ssdo.inputFC, ssdo.oidName,
contiguityType = contiguityType)
iterVals = master2Order.keys()
N = numObs
else:
gaTable = ssdo.gaTable
gaSearch = GAPY.ga_nsearch(gaTable)
if wType == 7:
#### Zone of Indiff, All Related to All ####
gaSearch.init_nearest(threshold, numObs, gaConcept)
else:
#### Inverse and Fixed Distances ####
gaSearch.init_nearest(threshold, 0, gaConcept)
iterVals = range(numObs)
N = numObs
neighWeights = ARC._ss.NeighborWeights(gaTable, gaSearch,
weight_type = wType,
exponent = exponent,
row_standard = rowStandard)
#### Create Progressor ####
msg = ARCPY.GetIDMessage(84007)
if self.permutations:
msg += ": Using Permutations = %i" % self.permutations
ARCPY.SetProgressor("step", msg , 0, N, 1)
#### Create Neighbor Info Class ####
ni = WU.NeighborInfo(masterField)
#### Calculation For Each Feature ####
for i in iterVals:
if self.swmFileBool:
#### Using SWM File ####
info = swm.swm.readEntry()
masterID = info[0]
if master2Order.has_key(masterID):
rowInfo = WU.getWeightsValuesSWM(info, master2Order,
self.yDev,
rowStandard = rowStandard,
isSubSet = isSubSet)
includeIt = True
else:
includeIt = False
elif self.weightsFile and not self.swmFileBool:
#### Text Weights ####
masterID = i
includeIt = True
rowInfo = WU.getWeightsValuesText(masterID, master2Order,
weightDict, self.yDev)
elif wType in [4, 5]:
#### Polygon Contiguity ####
masterID = i
includeIt = True
rowInfo = WU.getWeightsValuesCont(masterID, master2Order,
contDict, self.yDev,
rowStandard = rowStandard)
else:
#### Distance Based ####
masterID = gaTable[i][0]
includeIt = True
rowInfo = WU.getWeightsValuesOTF(neighWeights, i, self.yDev)
#### Subset Boolean for SWM File ####
if includeIt:
#### Parse Row Info ####
orderID, yiDev, nhIDs, nhVals, weights = rowInfo
#### Assure Neighbors Exist After Selection ####
nn, nhIDs, nhVals, weights = ni.processInfo(masterID, nhIDs,
nhVals, weights)
if nn:
#### Calculate Local I ####
self.calculateLI(orderID, yiDev,
nhVals, weights)
ARCPY.SetProgressorPosition()
#### Clean Up ####
if self.swmFileBool:
swm.close()
#### Report on Features with No Neighbors ####
ni.reportNoNeighbors()
self.setNullValues(ni.idsNoNeighs)
#### Report on Features with Large Number of Neighbors ####
ni.reportWarnings()
ni.reportMaximums()
self.neighInfo = ni
#### Set p-values for Gi Bins ####
if self.permutations:
#### Use Pseudo p-values ####
pv = self.pseudoPVals
else:
#### Use Traditional p-values ####
pv = self.pVals
#### Calculate FDR and Moran Bins ####
toolMSG = ARCPY.GetIDMessage(84474)
if self.applyFDR:
#### Set Bins Using FDR ####
msg = ARCPY.GetIDMessage(84472).format(toolMSG)
ARCPY.SetProgressor("default", msg)
fdrBins = STATS.fdrTransform(pv, self.li)
self.moranBins = STATS.moranBinFromPVals(pv, self.moranInfo,
fdrBins = fdrBins)
else:
msg = ARCPY.GetIDMessage(84473).format(toolMSG)
ARCPY.SetProgressor("default", msg)
self.moranBins = STATS.moranBinFromPVals(pv, self.moranInfo)
def construct(self):
"""Constructs the neighborhood structure for each feature and
dispatches the appropriate values for the calculation of the
statistic."""
#### Shorthand Attributes ####
ssdo = self.ssdo
numObs = ssdo.numObs
master2Order = ssdo.master2Order
masterField = ssdo.masterField
concept = self.concept
iterVals = range(numObs)
rowStandard = self.rowStandard
wType = 1
yVar = NUM.var(self.y)
if NUM.isnan(yVar) or yVar <= 0.0:
ARCPY.AddIDMessage("ERROR", 906)
raise SystemExit()
#### Create Deviation Variables ####
self.yBar = NUM.mean(self.y)
self.yDev = self.y - self.yBar
#### Create Results Array ####
self.giResults = NUM.zeros((self.nIncrements, 6))
#### Run Max Distance and Bin NN ####
msgProg = ARCPY.GetIDMessage(84423)
self.rowSum = NUM.zeros((numObs, self.nIncrements), float)
self.weightVals = NUM.ones((numObs, self.nIncrements), float)
self.noNeighs = NUM.zeros((self.nIncrements,), int)
self.breaks = COLL.defaultdict(NUM.array)
self.numFeatures = NUM.ones((self.nIncrements,), int) * ssdo.numObs
self.totalNeighs = NUM.zeros((self.nIncrements,), float)
ARCPY.SetProgressor("step", msgProg, 0, ssdo.numObs, 1)
if not self.silent:
ARCPY.AddMessage("\n" + msgProg)
gaSearch = GAPY.ga_nsearch(ssdo.gaTable)
gaSearch.init_nearest(self.stepMax, 0, concept.lower())
gaTable = ssdo.gaTable
numCalcs = 0
warnThrown = (self.silent == True) or (self.allDefaults == True)
self.warnNeighsExceeded = warnThrown
self.maxNeighsExceeded = warnThrown
self.completed = False
nb = ARC._ss.NeighborBins(gaTable, gaSearch, self.cutoffs)
c = 0
for counts, breaks in nb:
numDists = len(breaks)
if numDists:
#### Add Warning if Possibly Going to Run out of Memory ####
numCalcs += numDists
if numCalcs > 20000000 and not warnThrown:
if not self.silent:
ARCPY.AddIDMessage("WARNING", 1389)
warnThrown = True
self.breaks[c] = breaks
noNeighInd = NUM.where(counts == 0)[0]
if len(noNeighInd):
for noInd in noNeighInd:
self.noNeighs[noInd] += 1
self.numFeatures[noInd] -= 1
if rowStandard:
self.weightVals[c] = 1./counts
self.rowSum[c] = 1.0
else:
self.rowSum[c] = counts * 1.0
self.totalNeighs += counts
else:
#### Never Included in Spatial Autocorrelation ####
for ind in xrange(self.nIncrements):
self.noNeighs[ind] += 1
self.numFeatures[ind] -= 1
#### Warn Number of Neighs ####
if numDists >= WU.warnNumberOfNeighbors:
self.idsWarn.append(self.ssdo.order2Master[c])
if not self.warnNeighsExceeded:
ARCPY.AddIDMessage("WARNING", 1420,
WU.warnNumberOfNeighbors)
self.warnNeighsExceeded = True
c += 1
ARCPY.SetProgressorPosition()
#### Report if All Features Have No Neighbors ####
self.s0 = self.rowSum.sum(0)
noNeighsAllInd = NUM.where(self.s0 == 0.0)[0]
if len(noNeighsAllInd):
cutoffNoNeighs = self.cutoffs[noNeighsAllInd]
dist = [UTILS.formatValue(i, "%0.2f") for i in cutoffNoNeighs]
distanceStr = ", ".join(dist)
ARCPY.AddIDMessage("ERROR", 1388, distanceStr)
raise SystemExit()
#### Report on Features with Large Number of Neighbors ####
throwWarnings = (self.silent == True) or (self.allDefaults == True)
if not throwWarnings:
self.reportWarnings()
self.reportMaximums()
#### Calculate Statistic ####
msgProg = ARCPY.GetIDMessage(84280)
ARCPY.SetProgressor("step", msgProg, 0, ssdo.numObs, 1)
if not self.silent:
ARCPY.AddMessage("\n" + msgProg)
self.numer = NUM.zeros((self.nIncrements,), float)
self.denom = NUM.sum(self.yDev**2.0)
self.s1 = NUM.zeros((self.nIncrements,), float)
self.colSum = NUM.zeros((numObs, self.nIncrements), float)
for i in xrange(ssdo.numObs):
if self.breaks.has_key(i):
binIndices = self.breaks[i]
yDev0 = self.yDev[i]
gaSearch.search_by_idx(i)
w0 = self.weightVals[i]
c = 0
for nh in gaSearch:
start = binIndices[c]
yDev1 = self.yDev[nh.idx]
w1 = self.weightVals[nh.idx][start:]
w0c = w0[start:]
values = (yDev1 * w1) * yDev0
self.numer[start:] += values
self.s1[start:] += ((w0c + w1)**2.0)
self.colSum[i][start:] += w1
c += 1
ARCPY.SetProgressorPosition()
#### Calculate Moran's I ####
self.calculate()
#### Pack Results ####
for ind in self.cutoffOrder:
res = (self.cutoffs[ind], self.gi[ind], self.ei[ind],
self.vi[ind], self.zi[ind], self.pVal[ind])
self.giResults[ind] = res
if not self.silent:
ARCPY.AddMessage("\n")
#### Calculate Peak Distances ####
ziResults = [ value[4] for value in self.giResults ]
firstPeakInd, maxPeakInd = UTILS.returnPeakIndices(ziResults,
levelFilter = 1.65)
#### Add Warning if No Valid Peaks are Found ####
if firstPeakInd == None and maxPeakInd == None:
if not self.silent:
ARCPY.AddIDMessage("WARNING", 1284)
if firstPeakInd == None:
self.firstPeakDistance = None
self.firstPeakZ = None
else:
self.firstPeakDistance = self.cutoffs[firstPeakInd]
self.firstPeakZ = self.zi[firstPeakInd]
if maxPeakInd == None:
self.maxPeakDistance = None
self.maxPeakZ = None
else:
self.maxPeakDistance = self.cutoffs[maxPeakInd]
self.maxPeakZ = self.zi[maxPeakInd]
self.firstPeakInd = firstPeakInd
self.maxPeakInd = maxPeakInd
self.completed = True
return True
def polygon2SWM(inputFC, swmFile, masterField,
concept = "EUCLIDEAN", kNeighs = 0,
rowStandard = True, contiguityType = "ROOK"):
"""Creates a sparse spatial weights matrix (SWM) based on polygon
contiguity.
INPUTS:
inputFC (str): path to the input feature class
swmFile (str): path to the SWM file.
masterField (str): field in table that serves as the mapping.
concept: {str, EUCLIDEAN}: EUCLIDEAN or MANHATTAN
kNeighs {int, 0}: number of neighbors to return (1)
rowStandard {bool, True}: row standardize weights?
contiguityType {str, Rook}: {Rook = Edges Only, Queen = Edges/Vertices}
NOTES:
(1) kNeighs is used if polygon is not contiguous. E.g. Islands
"""
#### Set Default Progressor for Neigborhood Structure ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84143))
#### Create SSDataObject ####
ssdo = SSDO.SSDataObject(inputFC, templateFC = inputFC,
useChordal = True)
cnt = UTILS.getCount(inputFC)
ERROR.errorNumberOfObs(cnt, minNumObs = 2)
#### Validation of Master Field ####
verifyMaster = ERROR.checkField(ssdo.allFields, masterField,
types = [0,1])
#### Create GA Data Structure ####
gaTable, gaInfo = WU.gaTable(ssdo.catPath, [masterField],
spatRef = ssdo.spatialRefString)
#### Assure Enough Observations ####
N = gaInfo[0]
ERROR.errorNumberOfObs(N, minNumObs = 2)
#### Assure k-Nearest is Less Than Number of Features ####
if kNeighs >= N:
ARCPY.AddIDMessage("ERROR", 975)
raise SystemExit()
#### Create Nearest Neighbor Search Type For Islands ####
if kNeighs > 0:
gaSearch = GAPY.ga_nsearch(gaTable)
concept, gaConcept = WU.validateDistanceMethod(concept, ssdo.spatialRef)
gaSearch.init_nearest(0.0, kNeighs, gaConcept)
forceNeighbor = True
neighWeights = ARC._ss.NeighborWeights(gaTable, gaSearch,
weight_type = 1,
row_standard = False)
else:
forceNeighbor = False
neighSearch = None
#### Create Polygon Neighbors ####
polyNeighborDict = WU.polygonNeighborDict(inputFC, masterField,
contiguityType = contiguityType)
#### Write Poly Neighbor List (Dict) ####
#### Set Progressor for SWM Writing ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84127), 0, N, 1)
#### Initialize Spatial Weights Matrix File ####
if contiguityType == "ROOK":
wType = 4
else:
wType = 5
swmWriter = WU.SWMWriter(swmFile, masterField, ssdo.spatialRefName,
N, rowStandard, inputFC = inputFC,
wType = wType, distanceMethod = concept,
numNeighs = kNeighs)
#### Keep Track of Polygons w/o Neighbors ####
islandPolys = []
#### Write Polygon Contiguity to SWM File ####
for row in xrange(N):
rowInfo = gaTable[row]
oid = rowInfo[0]
masterID = rowInfo[2]
neighs = polyNeighborDict[masterID]
nn = len(neighs)
if forceNeighbor:
if nn < kNeighs:
#### Only Force KNN If Specified & Contiguity is Less ####
islandPolys.append(oid)
flag = True
knnNeighs, knnWeights = neighWeights[row]
c = 0
while flag:
try:
neighID = gaTable[knnNeighs[c]][2]
if neighID not in neighs:
neighs.append(neighID)
nn += 1
if nn == kNeighs:
flag = False
c += 1
except:
flag = False
weights = NUM.ones(nn)
#### Add Weights Entry ####
swmWriter.swm.writeEntry(masterID, neighs, weights)
#### Set Progress ####
ARCPY.SetProgressorPosition()
#### Report on Features with No Neighbors ####
countIslands = len(islandPolys)
if countIslands:
islandPolys.sort()
if countIslands > 30:
islandPolys = islandPolys[0:30]
ERROR.warningNoNeighbors(N, countIslands, islandPolys, ssdo.oidName,
forceNeighbor = forceNeighbor,
contiguity = True)
#### Clean Up ####
swmWriter.close()
del gaTable
#### Report Spatial Weights Summary ####
swmWriter.report()
#### Report SWM File is Large ####
swmWriter.reportLargeSWM()
del polyNeighborDict
def stCollectByKNN(ssdo, timeField, outputFC, inSpan, inDistance):
"""
This method applied Jacquez Space-Time K-NN to convert event data into weighted
point data by dissolving all coincident points in space and time into unique
points with a new count field that contains the number of original features
at that location and time span.
INPUTS:
ssdo (obj): SSDataObject from input
timeField (str): Date/Time field name in input feature
outputFC (str): path to the output feature class
inSpan (int): value of temporal units within the same time bin
inDistance (int): value of spatial units considered as spatial neighbors
OUTPUTS:
Create new collected point feature
"""
#### Read raw time data ####
timeData = ssdo.fields[timeField].data
#### Convert temporal unit ####
time = NUM.array(timeData, dtype='datetime64[s]').astype('datetime64[D]')
#### Find Start Time ####
startTime = time.min()
#### Create Bin for Space and Time ####
timeBin = (time - startTime) / inSpan
numObs = ssdo.numObs
#### Create Sudo-fid to Find K-NN in Space and Time
fid = [i for i in xrange(numObs)]
#### Validate Output Workspace ####
ERROR.checkOutputPath(outputFC)
#### True Centroid Warning For Non-Point FCs ####
if ssdo.shapeType.upper() != "POINT":
ARCPY / AddIDMessage("WARNING", 1021)
#### Create GA Data Structure ####
gaTable, gaInfo = WU.gaTable(ssdo.inputFC, spatRef=ssdo.spatialRefString)
#### Assure Enough Observations ####
cnt = UTILS.getCount(ssdo.inputFC)
ERROR.errorNumberOfObs(cnt, minNumObs=4)
N = gaInfo[0]
ERROR.errorNumberOfObs(N, minNumObs=4)
#### Process Any Bad Records Encountered ####
numBadRecs = cnt - N
if numBadRecs:
badRecs = WU.parseGAWarnings(gaTable.warnings)
if not ssdo.silentWarnings:
ERROR.reportBadRecords(cnt,
numBadRecs,
badRecs,
label=ssdo.oidName)
#### Create Output Feature Class ####
outPath, outName = OS.path.split(outputFC)
try:
DM.CreateFeatureclass(outPath, outName, "POINT", "", ssdo.mFlag,
ssdo.zFlag, ssdo.spatialRefString)
except:
ARCPY.AddIDMessage("ERROR", 210, outputFC)
raise SystemExit()
#### Create k-Nearest Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaSearch.init_nearest(inDistance, 0, "euclidean")
#### Add Count Field ####
countFieldNameOut = ARCPY.ValidateFieldName(countFieldName, outPath)
timeFieldNameOut = ARCPY.ValidateFieldName(timeFieldName, outPath)
UTILS.addEmptyField(outputFC, countFieldNameOut, "LONG")
UTILS.addEmptyField(outputFC, timeFieldNameOut, "DATE")
fieldList = ["SHAPE@", countFieldNameOut, timeFieldNameOut]
#### Set Insert Cursor ####
rowsOut = DA.InsertCursor(outputFC, fieldList)
#### Detect S-T K-NN by Space and Time Bin ####
duplicateList = []
for record in fid:
kNNList = [record]
if record not in duplicateList:
for pair in fid:
if pair != record:
gaSearch.search_by_idx(record)
for nh in gaSearch:
if timeBin[record] == timeBin[pair]:
kNNList.append(nh.idx)
duplicateList.append(nh.idx)
#### Create and Populate New Feature ####
kNNList = list(set(kNNList))
count = len(kNNList)
dt = time[record]
x0 = ssdo.xyCoords[kNNList, 0].mean()
y0 = ssdo.xyCoords[kNNList, 1].mean()
pnt = (x0, y0, ssdo.defaultZ)
rowResult = [pnt, count, dt]
rowsOut.insertRow(rowResult)
ARCPY.SetProgressorPosition()
#### Clean Up ####
del rowsOut, timeBin, kNNList, duplicateList
return countFieldNameOut
def kNearest2SWM(inputFC, swmFile, masterField, concept = "EUCLIDEAN",
kNeighs = 1, rowStandard = True):
"""Creates a sparse spatial weights matrix (SWM) based on k-nearest
neighbors.
INPUTS:
inputFC (str): path to the input feature class
swmFile (str): path to the SWM file.
masterField (str): field in table that serves as the mapping.
concept: {str, EUCLIDEAN}: EUCLIDEAN or MANHATTAN
kNeighs {int, 1}: number of neighbors to return
rowStandard {bool, True}: row standardize weights?
"""
#### Assure that kNeighs is Non-Zero ####
if kNeighs <= 0:
ARCPY.AddIDMessage("ERROR", 976)
raise SystemExit()
#### Set Default Progressor for Neigborhood Structure ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84143))
#### Create SSDataObject ####
ssdo = SSDO.SSDataObject(inputFC, templateFC = inputFC,
useChordal = True)
cnt = UTILS.getCount(inputFC)
ERROR.errorNumberOfObs(cnt, minNumObs = 2)
#### Validation of Master Field ####
verifyMaster = ERROR.checkField(ssdo.allFields, masterField, types = [0,1])
#### Create GA Data Structure ####
gaTable, gaInfo = WU.gaTable(ssdo.catPath, [masterField],
spatRef = ssdo.spatialRefString)
#### Assure Enough Observations ####
N = gaInfo[0]
ERROR.errorNumberOfObs(N, minNumObs = 2)
#### Process any bad records encountered ####
numBadRecs = cnt - N
if numBadRecs:
badRecs = WU.parseGAWarnings(gaTable.warnings)
err = ERROR.reportBadRecords(cnt, numBadRecs, badRecs,
label = ssdo.oidName)
#### Assure k-Nearest is Less Than Number of Features ####
if kNeighs >= N:
ARCPY.AddIDMessage("ERROR", 975)
raise SystemExit()
#### Create k-Nearest Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
concept, gaConcept = WU.validateDistanceMethod(concept, ssdo.spatialRef)
gaSearch.init_nearest(0.0, kNeighs, gaConcept)
neighWeights = ARC._ss.NeighborWeights(gaTable, gaSearch,
weight_type = 1,
row_standard = False)
#### Set Progressor for Weights Writing ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84127), 0, N, 1)
#### Initialize Spatial Weights Matrix File ####
swmWriter = WU.SWMWriter(swmFile, masterField, ssdo.spatialRefName,
N, rowStandard, inputFC = inputFC,
wType = 2, distanceMethod = concept,
numNeighs = kNeighs)
#### Unique Master ID Dictionary ####
masterSet = set([])
for row in xrange(N):
masterID = int(gaTable[row][2])
if masterID in masterSet:
ARCPY.AddIDMessage("Error", 644, masterField)
ARCPY.AddIDMessage("Error", 643)
raise SystemExit()
else:
masterSet.add(masterID)
neighs, weights = neighWeights[row]
neighs = [ gaTable[nh][2] for nh in neighs ]
#### Add Spatial Weights Matrix Entry ####
swmWriter.swm.writeEntry(masterID, neighs, weights)
#### Set Progress ####
ARCPY.SetProgressorPosition()
swmWriter.close()
del gaTable
#### Report Warning/Max Neighbors ####
swmWriter.reportNeighInfo()
#### Report Spatial Weights Summary ####
swmWriter.report()
#### Report SWM File is Large ####
swmWriter.reportLargeSWM()
def weightedCalc(self):
"""Performs weighted k-function."""
#### Attribute Shortcuts ####
ssdo = self.ssdo
reduce = self.reduce
simulate = self.simulate
ripley = self.ripley
numIDs = len(self.ids)
if reduce:
studyArea2Use = self.reduceArea
else:
studyArea2Use = self.studyArea
if simulate:
simOrder = []
for simKey, origID in self.simDict.iteritems():
simOrder.append(self.weightDict[origID])
self.ld = COLL.defaultdict(float)
if self.permutations:
self.ldMin = COLL.defaultdict(float)
self.ldMax = COLL.defaultdict(float)
for order in self.cutoffOrder:
self.ldMin[order] = 99999999999.
permsPlus = self.permutations + 1
for perm in xrange(0, permsPlus):
#### Permutation Progressor ####
pmsg = ARCPY.GetIDMessage(84184)
progressMessage = pmsg.format(perm, permsPlus)
ARCPY.SetProgressor("default", progressMessage)
gaSearch = GAPY.ga_nsearch(self.kTable)
gaSearch.init_nearest(self.stepMax, 0, "euclidean")
N = len(self.kTable)
#### Permutate Weights ####
if perm:
weights = RAND.permutation(weights)
else:
weights = self.weightVals
if simulate:
simWeights = NUM.take(self.weightVals, simOrder)
#### Set Statistic Variables ####
weightSumVal = 0.0
kij = COLL.defaultdict(float)
start = 0
#### Loop Over Entire Table ####
for i in xrange(N):
row = self.kTable[i]
id0 = row[0]
#### Calculate For Inside IDs ####
if id0 in self.ids:
x0,y0 = row[1]
weightInd0 = self.weightDict[id0]
w0 = weights[weightInd0]
#### Weight Sum Resolution ####
weightSumVal += (NUM.sum(w0 * weights)) - w0**2.0
if simulate:
weightSumVal += (w0 * simWeights).sum()
#### Neighbors Within Largest Distance ####
gaSearch.search_by_idx(i)
for nh in gaSearch:
neighInfo = self.kTable[nh.idx]
id1 = neighInfo[0]
x1,y1 = neighInfo[1]
#### Input or Simulated Point ####
try:
weightInd1 = self.weightDict[id1]
except:
origID = self.simDict[id1]
weightInd1 = self.weightDict[origID]
#### Process Neighbor Pair ####
w1 = weights[weightInd1]
dist = WU.euclideanDistance(x0,x1,y0,y1)
if ripley:
value = self.returnRipley(id0, dist)
else:
value = 1.0
value = w0 * (w1 * value)
#### Add To Cutoffs ####
for order in self.reverseOrder:
cutoff = self.cutoffs[order]
if dist > cutoff:
break
kij[order] += value
ARCPY.SetProgressorPosition()
#### Calculate Stats USing Dictionaries ####
denom = NUM.pi * weightSumVal
for order in self.cutoffOrder:
res = kij[order]
numer = res * studyArea2Use
permResult = NUM.sqrt( (numer/denom) )
if perm:
self.ldMin[order] = min(self.ldMin[order],
permResult)
self.ldMax[order] = max(self.ldMax[order],
permResult)
else:
self.ld[order] = permResult
def spaceTime2SWM(inputFC, swmFile, masterField, concept = "EUCLIDEAN",
threshold = None, rowStandard = True,
timeField = None, timeType = None,
timeValue = None):
"""
inputFC (str): path to the input feature class
swmFile (str): path to the SWM file.
masterField (str): field in table that serves as the mapping.
concept: {str, EUCLIDEAN}: EUCLIDEAN or MANHATTAN
threshold {float, None}: distance threshold
rowStandard {bool, True}: row standardize weights?
timeField {str, None}: name of the date-time field
timeType {str, None}: ESRI enumeration of date-time intervals
timeValue {float, None}: value forward and backward in time
"""
#### Assure Temporal Parameters are Set ####
if not timeField:
ARCPY.AddIDMessage("ERROR", 1320)
raise SystemExit()
if not timeType:
ARCPY.AddIDMessage("ERROR", 1321)
raise SystemExit()
if not timeValue or timeValue <= 0:
ARCPY.AddIDMessage("ERROR", 1322)
raise SystemExit()
#### Create SSDataObject ####
ssdo = SSDO.SSDataObject(inputFC, templateFC = inputFC,
useChordal = True)
cnt = UTILS.getCount(inputFC)
ERROR.errorNumberOfObs(cnt, minNumObs = 2)
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84001), 0, cnt, 1)
#### Validation of Master Field ####
verifyMaster = ERROR.checkField(ssdo.allFields, masterField, types = [0,1])
badIDs = []
#### Create Temporal Hash ####
timeInfo = {}
xyCoords = NUM.empty((cnt, 2), float)
#### Process Field Values ####
fieldList = [masterField, "SHAPE@XY", timeField]
try:
rows = DA.SearchCursor(ssdo.catPath, fieldList, "",
ssdo.spatialRefString)
except:
ARCPY.AddIDMessage("ERROR", 204)
raise SystemExit()
#### Add Data to GATable and Time Dictionary ####
c = 0
for row in rows:
badRow = False
#### Assure Masterfield is Valid ####
masterID = row[0]
if masterID == None or masterID == "":
badRow = True
#### Assure Date/Time is Valid ####
timeStamp = row[-1]
if timeStamp == None or timeStamp == "":
badRow = True
#### Assure Centroid is Valid ####
badXY = row[1].count(None)
if not badXY:
x,y = row[1]
xyCoords[c] = (x,y)
else:
badRow = True
#### Process Data ####
if not badRow:
if timeInfo.has_key(masterID):
#### Assure Uniqueness ####
ARCPY.AddIDMessage("Error", 644, masterField)
ARCPY.AddIDMessage("Error", 643)
raise SystemExit()
else:
#### Fill Date/Time Dict ####
startDT, endDT = TUTILS.calculateTimeWindow(timeStamp,
timeValue,
timeType)
timeInfo[masterID] = (timeStamp, startDT, endDT)
else:
badIDs.append(masterID)
#### Set Progress ####
c += 1
ARCPY.SetProgressorPosition()
#### Clean Up ####
del rows
#### Get Set of Bad IDs ####
numBadObs = len(badIDs)
badIDs = list(set(badIDs))
badIDs.sort()
badIDs = [ str(i) for i in badIDs ]
#### Process any bad records encountered ####
if numBadObs:
ERROR.reportBadRecords(cnt, numBadObs, badIDs, label = masterField)
#### Load Neighbor Table ####
gaTable, gaInfo = WU.gaTable(ssdo.inputFC,
fieldNames = [masterField, timeField],
spatRef = ssdo.spatialRefString)
numObs = len(gaTable)
xyCoords = xyCoords[0:numObs]
#### Set the Distance Threshold ####
concept, gaConcept = WU.validateDistanceMethod(concept, ssdo.spatialRef)
if threshold == None:
#### Set Progressor for Search ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84144))
#### Create k-Nearest Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaSearch.init_nearest(0.0, 1, gaConcept)
neighDist = ARC._ss.NeighborDistances(gaTable, gaSearch)
N = len(neighDist)
threshold = 0.0
sumDist = 0.0
#### Find Maximum Nearest Neighbor Distance ####
for row in xrange(N):
dij = neighDist[row][-1][0]
if dij > threshold:
threshold = dij
sumDist += dij
ARCPY.SetProgressorPosition()
#### Increase For Rounding Error ####
threshold = threshold * 1.0001
avgDist = sumDist / (N * 1.0)
#### Add Linear/Angular Units ####
thresholdStr = ssdo.distanceInfo.printDistance(threshold)
ARCPY.AddIDMessage("Warning", 853, thresholdStr)
#### Chordal Default Check ####
if ssdo.useChordal:
hardMaxExtent = ARC._ss.get_max_gcs_distance(ssdo.spatialRef)
if threshold > hardMaxExtent:
ARCPY.AddIDMessage("ERROR", 1609)
raise SystemExit()
#### Clean Up ####
del gaSearch
#### Create Missing SSDO Info ####
extent = UTILS.resetExtent(xyCoords)
#### Reset Coordinates for Chordal ####
if ssdo.useChordal:
sliceInfo = UTILS.SpheroidSlice(extent, ssdo.spatialRef)
maxExtent = sliceInfo.maxExtent
else:
env = UTILS.Envelope(extent)
maxExtent = env.maxExtent
threshold = checkDistanceThresholdSWM(ssdo, threshold, maxExtent)
#### Set Default Progressor for Neigborhood Structure ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84143))
#### Create Distance Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaSearch.init_nearest(threshold, 0, gaConcept)
neighSearch = ARC._ss.NeighborSearch(gaTable, gaSearch)
#### Set Progressor for Weights Writing ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84127), 0, numObs, 1)
#### Initialize Spatial Weights Matrix File ####
swmWriter = WU.SWMWriter(swmFile, masterField, ssdo.spatialRefName,
numObs, rowStandard, inputFC = inputFC,
wType = 9, distanceMethod = concept,
threshold = threshold, timeField = timeField,
timeType = timeType, timeValue = timeValue)
for row in xrange(numObs):
masterID = gaTable[row][2]
#### Get Date/Time Info ####
dt0, startDT0, endDT0 = timeInfo[masterID]
nhs = neighSearch[row]
neighs = []
weights = []
for nh in nhs:
#### Search Through Spatial Neighbors ####
neighID = gaTable[nh][2]
#### Get Date/Time Info ####
dt1, startDT1, endDT1 = timeInfo[neighID]
#### Filter Based on Date/Time ####
insideTimeWindow = TUTILS.isTimeNeighbor(startDT0, endDT0, dt1)
if insideTimeWindow:
neighs.append(neighID)
weights.append(1.0)
#### Add Spatial Weights Matrix Entry ####
swmWriter.swm.writeEntry(masterID, neighs, weights)
#### Set Progress ####
ARCPY.SetProgressorPosition()
swmWriter.close()
del gaTable
#### Report Warning/Max Neighbors ####
swmWriter.reportNeighInfo()
#### Report Spatial Weights Summary ####
swmWriter.report()
#### Report SWM File is Large ####
swmWriter.reportLargeSWM()
def calculateDistanceBand(inputFC, kNeighs, concept="EUCLIDEAN"):
"""Provides the minimum, maximum and average distance from a
set of features based on a given neighbor count.
INPUTS:
inputFC (str): path to the input feature class
kNeighs (int): number of neighbors to return
concept {str, EUCLIDEAN}: EUCLIDEAN or MANHATTAN distance
"""
#### Assure that kNeighs is Non-Zero ####
if kNeighs <= 0:
ARCPY.AddIDMessage("ERROR", 976)
raise SystemExit()
#### Set Default Progressor for Neigborhood Structure ####
ARCPY.SetProgressor("default", ARCPY.GetIDMessage(84143))
#### Create SSDataObject ####
ssdo = SSDO.SSDataObject(inputFC, useChordal=True)
cnt = UTILS.getCount(inputFC)
ERROR.errorNumberOfObs(cnt, minNumObs=2)
#### Create GA Data Structure ####
gaTable, gaInfo = WU.gaTable(inputFC, spatRef=ssdo.spatialRefString)
#### Assure Enough Observations ####
N = gaInfo[0]
ERROR.errorNumberOfObs(N, minNumObs=2)
#### Process Any Bad Records Encountered ####
numBadRecs = cnt - N
if numBadRecs:
badRecs = WU.parseGAWarnings(gaTable.warnings)
err = ERROR.reportBadRecords(cnt,
numBadRecs,
badRecs,
label=ssdo.oidName)
#### Assure k-Nearest is Less Than Number of Features ####
if kNeighs >= N:
ARCPY.AddIDMessage("ERROR", 975)
raise SystemExit()
#### Create k-Nearest Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaConcept = concept.lower()
gaSearch.init_nearest(0.0, kNeighs, gaConcept)
neighDist = ARC._ss.NeighborDistances(gaTable, gaSearch)
#### Set Progressor for Weights Writing ####
ARCPY.SetProgressor("step", ARCPY.GetIDMessage(84007), 0, N, 1)
distances = NUM.empty((N, ), float)
for row in xrange(N):
distances[row] = neighDist[row][-1].max()
ARCPY.SetProgressorPosition()
#### Calculate and Report ####
minDist = distances.min()
avgDist = distances.mean()
maxDist = distances.max()
if ssdo.useChordal:
hardMaxExtent = ARC._ss.get_max_gcs_distance(ssdo.spatialRef)
if maxDist > hardMaxExtent:
ARCPY.AddIDMessage("ERROR", 1609)
raise SystemExit()
minDistOut = LOCALE.format("%0.6f", minDist)
avgDistOut = LOCALE.format("%0.6f", avgDist)
maxDistOut = LOCALE.format("%0.6f", maxDist)
#### Create Output Text Table ####
header = ARCPY.GetIDMessage(84171)
row1 = [ARCPY.GetIDMessage(84165).format(kNeighs), minDistOut]
row2 = [ARCPY.GetIDMessage(84166).format(kNeighs), avgDistOut]
row3 = [ARCPY.GetIDMessage(84167).format(kNeighs), maxDistOut]
total = [row1, row2, row3]
tableOut = UTILS.outputTextTable(total, header=header, pad=1)
#### Add Linear/Angular Unit ####
distanceOut = ssdo.distanceInfo.outputString
distanceMeasuredStr = ARCPY.GetIDMessage(84344).format(distanceOut)
tableOut += "\n%s\n" % distanceMeasuredStr
#### Report Text Output ####
ARCPY.AddMessage(tableOut)
#### Set Derived Output ####
ARCPY.SetParameterAsText(3, minDist)
ARCPY.SetParameterAsText(4, avgDist)
ARCPY.SetParameterAsText(5, maxDist)
#### Clean Up ####
del gaTable
def construct(self):
"""Constructs the neighborhood structure for each feature and
dispatches the appropriate values for the calculation of the
statistic."""
#### Shorthand Attributes ####
ssdo = self.ssdo
varName = self.varName
concept = self.concept
gaConcept = concept.lower()
threshold = self.threshold
exponent = self.exponent
wType = self.wType
numObs = self.numObs
master2Order = self.master2Order
masterField = ssdo.masterField
weightsFile = self.weightsFile
potentialField = self.potentialField
#### Assure that Variance is Larger than Zero ####
yVar = NUM.var(self.y)
if NUM.isnan(yVar) or yVar <= 0.0:
ARCPY.AddIDMessage("ERROR", 906)
raise SystemExit()
#### Create Summed Variables ####
self.intRange = NUM.arange(numObs)
self.floatN = self.numObs * 1.0
ySum = self.y.sum()
ySum2 = (self.y**2.0).sum()
self.yBar = ySum / self.floatN
self.S = NUM.sqrt((ySum2 / self.floatN) - self.yBar**2.0)
self.nm1 = self.floatN - 1.0
#### Create Base Data Structures/Variables ####
self.gi = NUM.zeros(numObs)
self.pVals = NUM.ones(numObs)
if self.permutations:
self.pseudoPVals = NUM.ones(numObs)
#### Set Neighborhood Structure Type ####
if self.weightsFile:
if self.swmFileBool:
#### Open Spatial Weights and Obtain Chars ####
swm = WU.SWMReader(weightsFile)
N = swm.numObs
rowStandard = swm.rowStandard
self.swm = swm
#### Check to Assure Complete Set of Weights ####
if numObs > N:
ARCPY.AddIDMessage("ERROR", 842, numObs, N)
raise SystemExit()
#### Check if Selection Set ####
isSubSet = False
if numObs < N:
isSubSet = True
iterVals = xrange(N)
else:
#### Warning for GWT with Bad Records/Selection ####
if ssdo.selectionSet or ssdo.badRecords:
ARCPY.AddIDMessage("WARNING", 1029)
#### Build Weights Dictionary ####
weightDict = WU.buildTextWeightDict(weightsFile, master2Order)
iterVals = master2Order.keys()
N = numObs
elif wType in [4, 5]:
#### Polygon Contiguity ####
if wType == 4:
contiguityType = "ROOK"
else:
contiguityType = "QUEEN"
contDict = WU.polygonNeighborDict(ssdo.inputFC,
ssdo.oidName,
contiguityType=contiguityType)
iterVals = master2Order.keys()
N = numObs
else:
gaTable = ssdo.gaTable
gaSearch = GAPY.ga_nsearch(gaTable)
if wType == 7:
#### Zone of Indiff, All Related to All ####
gaSearch.init_nearest(threshold, numObs, gaConcept)
else:
#### Inverse and Fixed Distances ####
gaSearch.init_nearest(threshold, self.numNeighs, gaConcept)
iterVals = range(numObs)
N = numObs
neighWeights = ARC._ss.NeighborWeights(gaTable,
gaSearch,
weight_type=wType,
exponent=exponent,
row_standard=False,
include_self=True)
#### Create Progressor ####
msg = ARCPY.GetIDMessage(84007)
if self.permutations:
msg += ": Using Permutations = %i" % self.permutations
ARCPY.SetProgressor("step", msg, 0, N, 1)
#### Create Neighbor Info Class ####
ni = WU.NeighborInfo(masterField)
#### Calculation For Each Feature ####
for i in iterVals:
if self.swmFileBool:
#### Using SWM File ####
info = swm.swm.readEntry()
masterID = info[0]
if master2Order.has_key(masterID):
rowInfo = WU.getWeightsValuesSWM(info,
master2Order,
self.y,
rowStandard=rowStandard,
potVals=self.potVals)
includeIt = True
else:
includeIt = False
elif self.weightsFile and not self.swmFileBool:
#### Text Weights ####
masterID = i
includeIt = True
rowInfo = WU.getWeightsValuesText(masterID,
master2Order,
weightDict,
self.y,
potVals=self.potVals,
allowSelf=True)
elif wType in [4, 5]:
#### Polygon Contiguity ####
masterID = i
includeIt = True
rowInfo = WU.getWeightsValuesCont(masterID,
master2Order,
contDict,
self.y,
rowStandard=False,
potVals=self.potVals)
else:
#### Distance Based ####
masterID = gaTable[i][0]
includeIt = True
rowInfo = WU.getWeightsValuesOTF_Potent(
neighWeights, i, self.y, self.potVals)
#### Subset Boolean for SWM File ####
if includeIt:
#### Parse Row Info ####
orderID, yiVal, nhIDs, nhVals, weights = rowInfo
#### Assure Neighbors Exist After Selection ####
nn, nhIDs, nhVals, weights = ni.processInfo(
masterID, nhIDs, nhVals, weights)
if nn:
#### Calculate Local G ####
self.calculateGI(orderID, yiVal, nhVals, weights)
ARCPY.SetProgressorPosition()
#### Clean Up ####
if self.swmFileBool:
swm.close()
#### Report on Features with No Neighbors ####
ni.reportNoNeighbors(failAllNoNeighs=False)
self.setNullValues(ni.idsNoNeighs)
#### Report on Features with Large Number of Neighbors ####
ni.reportWarnings()
ni.reportMaximums()
self.neighInfo = ni
#### Set p-values for Gi Bins ####
if self.permutations:
#### Use Pseudo p-values ####
pv = self.pseudoPVals
else:
#### Use Traditional p-values ####
pv = self.pVals
toolMSG = ARCPY.GetIDMessage(84466)
if self.applyFDR:
#### Set Bins Using FDR ####
msg = ARCPY.GetIDMessage(84472).format(toolMSG)
ARCPY.SetProgressor("default", msg)
self.giBins = STATS.fdrTransform(pv, self.gi)
else:
msg = ARCPY.GetIDMessage(84473).format(toolMSG)
ARCPY.SetProgressor("default", msg)
self.giBins = STATS.pValueBins(pv, self.gi)
def stCollectByKNN(ssdo, timeField, outputFC, inSpan, inDistance):
"""
This method applied Jacquez Space-Time K-NN to convert event data into weighted
point data by dissolving all coincident points in space and time into unique
points with a new count field that contains the number of original features
at that location and time span.
INPUTS:
ssdo (obj): SSDataObject from input
timeField (str): Date/Time field name in input feature
outputFC (str): path to the output feature class
inSpan (int): value of temporal units within the same time bin
inDistance (int): value of spatial units considered as spatial neighbors
OUTPUTS:
Create new collected point feature
"""
#### Read raw time data ####
timeData = ssdo.fields[timeField].data
#### Convert temporal unit ####
time = NUM.array(timeData, dtype = 'datetime64[s]').astype('datetime64[D]')
#### Find Start Time ####
startTime = time.min()
#### Create Bin for Space and Time ####
timeBin = (time - startTime) / inSpan
numObs = ssdo.numObs
#### Create Sudo-fid to Find K-NN in Space and Time
fid = [i for i in xrange(numObs)]
#### Validate Output Workspace ####
ERROR.checkOutputPath(outputFC)
#### True Centroid Warning For Non-Point FCs ####
if ssdo.shapeType.upper() != "POINT":
ARCPY/AddIDMessage("WARNING", 1021)
#### Create GA Data Structure ####
gaTable, gaInfo = WU.gaTable(ssdo.inputFC, spatRef = ssdo.spatialRefString)
#### Assure Enough Observations ####
cnt = UTILS.getCount(ssdo.inputFC)
ERROR.errorNumberOfObs(cnt, minNumObs = 4)
N = gaInfo[0]
ERROR.errorNumberOfObs(N, minNumObs = 4)
#### Process Any Bad Records Encountered ####
numBadRecs = cnt -N
if numBadRecs:
badRecs = WU.parseGAWarnings(gaTable.warnings)
if not ssdo.silentWarnings:
ERROR.reportBadRecords(cnt, numBadRecs, badRecs, label = ssdo.oidName)
#### Create Output Feature Class ####
outPath, outName = OS.path.split(outputFC)
try:
DM.CreateFeatureclass(outPath, outName, "POINT", "", ssdo.mFlag,
ssdo.zFlag, ssdo.spatialRefString)
except:
ARCPY.AddIDMessage("ERROR", 210, outputFC)
raise SystemExit()
#### Create k-Nearest Neighbor Search Type ####
gaSearch = GAPY.ga_nsearch(gaTable)
gaSearch.init_nearest(inDistance, 0, "euclidean")
#### Add Count Field ####
countFieldNameOut = ARCPY.ValidateFieldName(countFieldName, outPath)
timeFieldNameOut = ARCPY.ValidateFieldName(timeFieldName, outPath)
UTILS.addEmptyField(outputFC, countFieldNameOut, "LONG")
UTILS.addEmptyField(outputFC, timeFieldNameOut, "DATE")
fieldList = ["SHAPE@", countFieldNameOut, timeFieldNameOut]
#### Set Insert Cursor ####
rowsOut = DA.InsertCursor(outputFC, fieldList)
#### Detect S-T K-NN by Space and Time Bin ####
duplicateList = []
for record in fid:
kNNList = [record]
if record not in duplicateList:
for pair in fid:
if pair != record :
gaSearch.search_by_idx(record)
for nh in gaSearch:
if timeBin[record] == timeBin[pair]:
kNNList.append(nh.idx)
duplicateList.append(nh.idx)
#### Create and Populate New Feature ####
kNNList = list(set(kNNList))
count = len(kNNList)
dt = time[record]
x0 = ssdo.xyCoords[kNNList, 0].mean()
y0 = ssdo.xyCoords[kNNList, 1].mean()
pnt =(x0, y0, ssdo.defaultZ)
rowResult = [pnt, count, dt]
rowsOut.insertRow(rowResult)
ARCPY.SetProgressorPosition()
#### Clean Up ####
del rowsOut, timeBin, kNNList, duplicateList
return countFieldNameOut