def _minCostMaxFlowMergerResolving(self, objectFeatures, transitionClassifier=None, transitionParameter=5.0):
"""
Find the optimal assignments within the `resolvedGraph` by running min-cost max-flow from the
`dpct` module.
Converts the `resolvedGraph` to our JSON model structure, predicts the transition probabilities
either using the given transitionClassifier, or using distance-based probabilities.
**returns** a `nodeFlowMap` and `arcFlowMap` holding information on the usage of the respective nodes and links
**Note:** cannot use `networkx` flow methods because they don't work with floating point weights.
"""
trackingGraph = JsonTrackingGraph()
for node in self.resolvedGraph.nodes_iter():
additionalFeatures = {}
# nodes with no in/out
numStates = 2
if len(self.resolvedGraph.in_edges(node)) == 0:
# division nodes with no incoming arcs offer 2 units of flow without the need to de-merge
if node in self.unresolvedGraph.nodes() and self.unresolvedGraph.node[node]['division'] and len(self.unresolvedGraph.out_edges(node)) == 2:
numStates = 3
additionalFeatures['appearanceFeatures'] = [[i**2 * 0.01] for i in range(numStates)]
if len(self.resolvedGraph.out_edges(node)) == 0:
assert(numStates == 2) # division nodes with no incoming should have outgoing, or they shouldn't show up in resolved graph
additionalFeatures['disappearanceFeatures'] = [[i**2 * 0.01] for i in range(numStates)]
features = [[i**2] for i in range(numStates)]
uuid = trackingGraph.addDetectionHypotheses(features, **additionalFeatures)
self.resolvedGraph.node[node]['id'] = uuid
for edge in self.resolvedGraph.edges_iter():
src = self.resolvedGraph.node[edge[0]]['id']
dest = self.resolvedGraph.node[edge[1]]['id']
featuresAtSrc = objectFeatures[edge[0]]
featuresAtDest = objectFeatures[edge[1]]
if transitionClassifier is not None:
try:
featVec = self.pluginManager.applyTransitionFeatureVectorConstructionPlugins(
featuresAtSrc, featuresAtDest, transitionClassifier.selectedFeatures)
except:
getLogger().error("Could not compute transition features of link {}->{}:".format(src, dest))
getLogger().error(featuresAtSrc)
getLogger().error(featuresAtDest)
raise
featVec = np.expand_dims(np.array(featVec), axis=0)
probs = transitionClassifier.predictProbabilities(featVec)[0]
else:
dist = np.linalg.norm(featuresAtDest['RegionCenter'] - featuresAtSrc['RegionCenter'])
prob = np.exp(-dist / transitionParameter)
probs = [1.0 - prob, prob]
trackingGraph.addLinkingHypotheses(src, dest, listify(negLog(probs)))
# track
import dpct
weights = {"weights": [1, 1, 1, 1]}
mergerResult = dpct.trackMaxFlow(trackingGraph.model, weights)
# transform results to dictionaries that can be indexed by id or (src,dest)
nodeFlowMap = dict([(int(d['id']), int(d['value'])) for d in mergerResult['detectionResults']])
arcFlowMap = dict([((int(l['src']), int(l['dest'])), int(l['value'])) for l in mergerResult['linkingResults']])
return nodeFlowMap, arcFlowMap
def _minCostMaxFlowMergerResolving(self,
objectFeatures,
transitionClassifier=None,
transitionParameter=5.0):
"""
Find the optimal assignments within the `resolvedGraph` by running min-cost max-flow from the
`dpct` module.
Converts the `resolvedGraph` to our JSON model structure, predicts the transition probabilities
either using the given transitionClassifier, or using distance-based probabilities.
**returns** a `nodeFlowMap` and `arcFlowMap` holding information on the usage of the respective nodes and links
**Note:** cannot use `networkx` flow methods because they don't work with floating point weights.
"""
trackingGraph = JsonTrackingGraph(progressVisitor=self.progressVisitor)
for node in self.resolvedGraph.nodes_iter():
additionalFeatures = {}
additionalFeatures['nid'] = node
# nodes with no in/out
numStates = 2
if len(self.resolvedGraph.in_edges(node)) == 0:
# division nodes with no incoming arcs offer 2 units of flow without the need to de-merge
if node in self.unresolvedGraph.nodes(
) and self.unresolvedGraph.node[node]['division'] and len(
self.unresolvedGraph.out_edges(node)) == 2:
numStates = 3
additionalFeatures['appearanceFeatures'] = [
[i**2 * 0.01] for i in range(numStates)
]
if len(self.resolvedGraph.out_edges(node)) == 0:
assert (
numStates == 2
) # division nodes with no incoming should have outgoing, or they shouldn't show up in resolved graph
additionalFeatures['disappearanceFeatures'] = [
[i**2 * 0.01] for i in range(numStates)
]
features = [[i**2] for i in range(numStates)]
uuid = trackingGraph.addDetectionHypotheses(
features, **additionalFeatures)
self.resolvedGraph.node[node]['id'] = uuid
for edge in self.resolvedGraph.edges_iter():
src = self.resolvedGraph.node[edge[0]]['id']
dest = self.resolvedGraph.node[edge[1]]['id']
featuresAtSrc = objectFeatures[edge[0]]
featuresAtDest = objectFeatures[edge[1]]
if transitionClassifier is not None:
try:
featVec = self.pluginManager.applyTransitionFeatureVectorConstructionPlugins(
featuresAtSrc, featuresAtDest,
transitionClassifier.selectedFeatures)
except:
getLogger().error(
"Could not compute transition features of link {}->{}:"
.format(src, dest))
getLogger().error(featuresAtSrc)
getLogger().error(featuresAtDest)
raise
featVec = np.expand_dims(np.array(featVec), axis=0)
probs = transitionClassifier.predictProbabilities(featVec)[0]
else:
dist = np.linalg.norm(featuresAtDest['RegionCenter'] -
featuresAtSrc['RegionCenter'])
prob = np.exp(-dist / transitionParameter)
probs = [1.0 - prob, prob]
trackingGraph.addLinkingHypotheses(src, dest,
listify(negLog(probs)))
# Set TraxelToUniqueId on resolvedGraph's json graph
uuidToTraxelMap = {}
traxelIdPerTimestepToUniqueIdMap = {}
for node in self.resolvedGraph.nodes_iter():
uuid = self.resolvedGraph.node[node]['id']
uuidToTraxelMap[uuid] = [node]
for t in uuidToTraxelMap[uuid]:
traxelIdPerTimestepToUniqueIdMap.setdefault(str(t[0]), {})[str(
t[1])] = uuid
trackingGraph.setTraxelToUniqueId(traxelIdPerTimestepToUniqueIdMap)
# track
import dpct
weights = {"weights": [1, 1, 1, 1]}
if not self.numSplits:
mergerResult = dpct.trackMaxFlow(trackingGraph.model, weights)
else:
getLogger().info("Running split tracking with {} splits.".format(
self.numSplits))
mergerResult = SplitTracking.trackFlowBasedWithSplits(
trackingGraph.model,
weights,
numSplits=self.numSplits,
withMergerResolver=True)
# transform results to dictionaries that can be indexed by id or (src,dest)
nodeFlowMap = dict([(int(d['id']), int(d['value']))
for d in mergerResult['detectionResults']])
arcFlowMap = dict([((int(l['src']), int(l['dest'])), int(l['value']))
for l in mergerResult['linkingResults']])
return nodeFlowMap, arcFlowMap
def _minCostMaxFlowMergerResolving(self,
objectFeatures,
transitionClassifier=None,
transitionParameter=5.0):
"""
Find the optimal assignments within the `resolvedGraph` by running min-cost max-flow from the
`dpct` module.
Converts the `resolvedGraph` to our JSON model structure, predicts the transition probabilities
either using the given transitionClassifier, or using distance-based probabilities.
**returns** a `nodeFlowMap` and `arcFlowMap` holding information on the usage of the respective nodes and links
**Note:** cannot use `networkx` flow methods because they don't work with floating point weights.
"""
trackingGraph = JsonTrackingGraph()
for node in self.resolvedGraph.nodes_iter():
additionalFeatures = {}
if len(self.resolvedGraph.in_edges(node)) == 0:
additionalFeatures['appearanceFeatures'] = [[0], [0]]
if len(self.resolvedGraph.out_edges(node)) == 0:
additionalFeatures['disappearanceFeatures'] = [[0], [0]]
uuid = trackingGraph.addDetectionHypotheses([[0], [1]],
**additionalFeatures)
self.resolvedGraph.node[node]['id'] = uuid
for edge in self.resolvedGraph.edges_iter():
src = self.resolvedGraph.node[edge[0]]['id']
dest = self.resolvedGraph.node[edge[1]]['id']
featuresAtSrc = objectFeatures[edge[0]]
featuresAtDest = objectFeatures[edge[1]]
if transitionClassifier is not None:
try:
featVec = self.pluginManager.applyTransitionFeatureVectorConstructionPlugins(
featuresAtSrc, featuresAtDest,
transitionClassifier.selectedFeatures)
except:
getLogger().error(
"Could not compute transition features of link {}->{}:"
.format(src, dest))
getLogger().error(featuresAtSrc)
getLogger().error(featuresAtDest)
raise
featVec = np.expand_dims(np.array(featVec), axis=0)
probs = transitionClassifier.predictProbabilities(featVec)[0]
else:
dist = np.linalg.norm(featuresAtDest['RegionCenter'] -
featuresAtSrc['RegionCenter'])
prob = np.exp(-dist / transitionParameter)
probs = [1.0 - prob, prob]
trackingGraph.addLinkingHypotheses(src, dest,
listify(negLog(probs)))
# track
import dpct
weights = {"weights": [1, 1, 1, 1]}
mergerResult = dpct.trackMaxFlow(trackingGraph.model, weights)
# transform results to dictionaries that can be indexed by id or (src,dest)
nodeFlowMap = dict([(int(d['id']), int(d['value']))
for d in mergerResult['detectionResults']])
arcFlowMap = dict([((int(l['src']), int(l['dest'])), int(l['value']))
for l in mergerResult['linkingResults']])
return nodeFlowMap, arcFlowMap