// Fields("frameId", "frameMat", "patchCount"));
private void processFrame(Tuple tuple) {
int frameId = tuple.getIntegerByField(FIELD_FRAME_ID);
Serializable.Mat mat = (Serializable.Mat) tuple.getValueByField(FIELD_FRAME_MAT);
int patchCount = tuple.getIntegerByField(FIELD_PATCH_COUNT);
if (frameMap.containsKey(frameId)) {
if (Debug.topologyDebugOutput)
System.err.println(this.getClass() + "#" + "processFrame(): Received duplicate frame");
} else {
frameMap.put(frameId, mat);
}
if (patchQueue.containsKey(frameId)) {
Queue<Serializable.PatchIdentifier> queue = patchQueue.get(frameId);
while (!queue.isEmpty()) {
Serializable.PatchIdentifier hostPatch = queue.poll();
List<Serializable.Rect> detectedLogoList = new ArrayList<>();
SIFTfeatures sifTfeatures =
new SIFTfeatures(sift, mat.toJavaCVMat(), hostPatch.roi.toJavaCVRect(), true);
for (int logoIndex = 0; logoIndex < detectors.size(); logoIndex++) {
StormVideoLogoDetectorGamma detector = detectors.get(logoIndex);
// detector.detectLogosInRoi(mat.toJavaCVMat(), hostPatch.roi.toJavaCVRect());
detector.detectLogosByFeatures(sifTfeatures);
Serializable.Rect detectedLogo = detector.getFoundRect();
if (detectedLogo != null) {
collector.emit(
LOGO_TEMPLATE_UPDATE_STREAM,
new Values(hostPatch, detectedLogo, detector.getParentIdentifier(), logoIndex));
}
detectedLogoList.add(detectedLogo);
}
collector.emit(
DETECTED_LOGO_STREAM,
tuple,
new Values(frameId, hostPatch, detectedLogoList, patchCount));
}
} else {
// patchQueue.put(frameId, new LinkedList<>());
}
if (templateQueue.containsKey(frameId)) {
Queue<LogoTemplateUpdateBeta> queue = templateQueue.get(frameId);
while (!queue.isEmpty()) {
LogoTemplateUpdateBeta update = queue.poll();
Serializable.Rect roi = update.detectedLogoRect;
Serializable.PatchIdentifier hostPatchIdentifier = update.hostPatchIdentifier;
Serializable.PatchIdentifier parent = update.parentIdentifier;
int logoIndex = update.logoIndex;
/// detector.addTemplateByRect(hostPatchIdentifier, mat, roi);
/// detector.incrementPriority(parent, 1);
detectors.get(logoIndex).addTemplateByRect(hostPatchIdentifier, mat, roi);
detectors.get(logoIndex).incrementPriority(parent, 1);
}
} else {
// templateQueue.put(frameId, new LinkedList<>());
}
}
// Fields("hostPatchIdentifier", "detectedLogoRect", "parentIdentifier"));
private void processNewTemplate(Tuple tuple) {
Serializable.PatchIdentifier receivedPatchIdentifier =
(Serializable.PatchIdentifier) tuple.getValueByField(FIELD_HOST_PATCH_IDENTIFIER);
// TODO: This container could become very large, need to clear it after some time
// Modified by Tom, use LinkedHashMap for receivedUpdatesFrom, it will automatically remove the
// oldest
// element when its size beyond some threshold.
if (!receivedUpdatesFrom.containsKey(receivedPatchIdentifier)) {
receivedUpdatesFrom.put(receivedPatchIdentifier, Boolean.TRUE);
Serializable.Rect roi = (Serializable.Rect) tuple.getValueByField(FIELD_DETECTED_LOGO_RECT);
Serializable.PatchIdentifier parent =
(Serializable.PatchIdentifier) tuple.getValueByField(FIELD_PARENT_PATCH_IDENTIFIER);
int logoIndex = tuple.getIntegerByField(FIELD_LOGO_INDEX);
int frameId = receivedPatchIdentifier.frameId;
if (frameMap.containsKey(frameId)) {
Serializable.Mat mat = frameMap.get(frameId);
detectors.get(logoIndex).addTemplateByRect(receivedPatchIdentifier, mat, roi);
detectors.get(logoIndex).incrementPriority(parent, 1);
} else {
if (!templateQueue.containsKey(frameId)) templateQueue.put(frameId, new LinkedList<>());
templateQueue
.get(frameId)
.add(new LogoTemplateUpdateBeta(receivedPatchIdentifier, roi, parent, logoIndex));
}
} else {
if (Debug.topologyDebugOutput)
System.out.println("PatchProcessorBolt: Received duplicate message");
}
}
// Fields("patchIdentifier", "patchCount"));
private void processPatch(Tuple tuple) {
Serializable.PatchIdentifier patchIdentifier =
(Serializable.PatchIdentifier) tuple.getValueByField(FIELD_PATCH_IDENTIFIER);
int patchCount = tuple.getIntegerByField(FIELD_PATCH_COUNT);
int frameId = patchIdentifier.frameId;
if (frameMap.containsKey(frameId)) {
List<Serializable.Rect> detectedLogoList = new ArrayList<>();
SIFTfeatures sifTfeatures =
new SIFTfeatures(
sift, frameMap.get(frameId).toJavaCVMat(), patchIdentifier.roi.toJavaCVRect(), true);
for (int logoIndex = 0; logoIndex < detectors.size(); logoIndex++) {
StormVideoLogoDetectorGamma detector = detectors.get(logoIndex);
// detector.detectLogosInRoi(frameMap.get(frameId).toJavaCVMat(),
// patchIdentifier.roi.toJavaCVRect());
detector.detectLogosByFeatures(sifTfeatures);
Serializable.Rect detectedLogo = detector.getFoundRect();
if (detectedLogo != null) {
collector.emit(
LOGO_TEMPLATE_UPDATE_STREAM,
new Values(patchIdentifier, detectedLogo, detector.getParentIdentifier(), logoIndex));
}
detectedLogoList.add(detectedLogo);
}
collector.emit(
DETECTED_LOGO_STREAM,
tuple,
new Values(frameId, patchIdentifier, detectedLogoList, patchCount));
} else {
if (!patchQueue.containsKey(frameId)) patchQueue.put(frameId, new LinkedList<>());
patchQueue.get(frameId).add(patchIdentifier);
}
}
@Override
public void prepare(Map map, TopologyContext topologyContext, OutputCollector outputCollector) {
int minNumberOfMatches = Math.min(getInt(map, "minNumberOfMatches"), 4);
this.collector = outputCollector;
// TODO: get path to logos & parameters from config
Parameters parameters =
new Parameters()
.withMatchingParameters(
new Parameters.MatchingParameters().withMinimalNumberOfMatches(minNumberOfMatches));
sift =
new opencv_nonfree.SIFT(
0,
3,
parameters.getSiftParameters().getContrastThreshold(),
parameters.getSiftParameters().getEdgeThreshold(),
parameters.getSiftParameters().getSigma());
List<String> templateFiles = getListOfStrings(map, "originalTemplateFileNames");
int maxAdditionTemp = ConfigUtil.getInt(map, "maxAdditionTemp", 4);
detectors = new ArrayList<>();
for (int logoIndex = 0; logoIndex < templateFiles.size(); logoIndex++) {
detectors.add(
new StormVideoLogoDetectorGamma(
parameters, templateFiles.get(logoIndex), logoIndex, maxAdditionTemp));
}
// detector = new StormVideoLogoDetector(parameters, templateFiles);
// receivedUpdatesFrom = new HashSet<>();
// Modified by Tom on Sep 8, 2014
receivedUpdatesFrom =
new LinkedHashMap<Serializable.PatchIdentifier, Boolean>() {
@Override
protected boolean removeEldestEntry(
Map.Entry<Serializable.PatchIdentifier, Boolean> eldest) {
return size() > MaxSizeOfReceivedUpdatesFrom;
}
};
frameMap = new HashMap<>();
patchQueue = new HashMap<>();
templateQueue = new HashMap<>();
}