Test fire and smoke

This commit is contained in:
2026-05-28 16:03:16 +10:00
parent ffcf5fc873
commit e70acb463e
5 changed files with 287 additions and 107 deletions
+11 -1
View File
@@ -50,7 +50,17 @@
"Bash(tr ';' '\\\\n')",
"Bash(ls -la \"C:/ProgramData/ANSCENTER/DLHUB_Runtime_Engine/\"*.dll)",
"Bash(cp \"C:/ProgramData/ANSCENTER/Shared/ANSLicensingSystem.dll\" \"C:/ProgramData/ANSCENTER/DLHUB_Runtime_Engine/ANSLicensingSystem.dll\")",
"Bash(cp \"C:/ProgramData/ANSCENTER/Shared/anslicensing.dll\" \"C:/ProgramData/ANSCENTER/DLHUB_Runtime_Engine/anslicensing.dll\")"
"Bash(cp \"C:/ProgramData/ANSCENTER/Shared/anslicensing.dll\" \"C:/ProgramData/ANSCENTER/DLHUB_Runtime_Engine/anslicensing.dll\")",
"Bash(cmake --build cmake-build-release --target ANSCustomFireNSmokeDetection)",
"Bash(cmd.exe /c \"call \\\\\"C:\\\\\\\\Program Files\\\\\\\\Microsoft Visual Studio\\\\\\\\2022\\\\\\\\Community\\\\\\\\VC\\\\\\\\Auxiliary\\\\\\\\Build\\\\\\\\vcvars64.bat\\\\\" >nul 2>&1 && cmake --build cmake-build-release --target ANSCustomFireNSmokeDetection\")",
"Bash(cmd.exe //c \"call \\\\\"C:\\\\Program Files\\\\Microsoft Visual Studio\\\\2022\\\\Community\\\\VC\\\\Auxiliary\\\\Build\\\\vcvars64.bat\\\\\" >nul && cmake --build cmake-build-release --target ANSCustomFireNSmokeDetection 2>&1\")",
"Bash(cmd.exe /c C:/Projects/CLionProjects/ANSCustomModels/_build_fns.bat)",
"Bash(cmd.exe /c 'C:\\\\Projects\\\\CLionProjects\\\\ANSCustomModels\\\\_build_fns.bat')",
"Bash(/c/Projects/CLionProjects/ANSCustomModels/_build_fns.bat)",
"PowerShell($dll = \"C:\\\\ProgramData\\\\ANSCENTER\\\\Shared\\\\ANSLibsLoader.dll\"; if \\(Test-Path $dll\\) { Get-Item $dll | Select-Object Name, Length, LastWriteTime, VersionInfo | Format-List } else { \"DLL not found at $dll\" })",
"PowerShell($bytes = [System.IO.File]::ReadAllBytes\\(\"C:\\\\ProgramData\\\\ANSCENTER\\\\Shared\\\\ANSLibsLoader.dll\"\\); $text = [System.Text.Encoding]::ASCII.GetString\\($bytes\\); if \\($text -match \"ANSCENTER_DebugLog\"\\) { \"FOUND: ANSCENTER_DebugLog symbol present in DLL\" } else { \"MISSING: ANSCENTER_DebugLog NOT present in DLL\" }; if \\($text -match \"ANSCENTER_IsDebugViewEnabled\"\\) { \"FOUND: ANSCENTER_IsDebugViewEnabled symbol present\" } else { \"MISSING: ANSCENTER_IsDebugViewEnabled NOT present\" })",
"PowerShell($bytes = [System.IO.File]::ReadAllBytes\\(\"C:\\\\ProgramData\\\\ANSCENTER\\\\Shared\\\\ANSLIB.dll\"\\); $text = [System.Text.Encoding]::ASCII.GetString\\($bytes\\); $matches = [regex]::Matches\\($text, \"ANSCENTER_[A-Za-z]+\"\\); $matches | ForEach-Object { $_.Value } | Sort-Object -Unique)",
"Bash(cmake --build C:/Projects/CLionProjects/ANSCustomModels/cmake-build-release --target FireNSmokeDetection_Demo --config Release)"
]
}
}
+1
View File
@@ -139,6 +139,7 @@
<option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppNotAllPathsReturnValue/@EntryIndexedValue" value="WARNING" type="string" />
<option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppObjectMemberMightNotBeInitialized/@EntryIndexedValue" value="WARNING" type="string" />
<option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppOutParameterMustBeWritten/@EntryIndexedValue" value="WARNING" type="string" />
<option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppOverrideWithDifferentVisibility/@EntryIndexedValue" value="WARNING" type="string" />
<option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppParameterMayBeConst/@EntryIndexedValue" value="HINT" type="string" />
<option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppParameterMayBeConstPtrOrRef/@EntryIndexedValue" value="SUGGESTION" type="string" />
<option name="/Default/CodeInspection/Highlighting/InspectionSeverities/=CppParameterNamesMismatch/@EntryIndexedValue" value="HINT" type="string" />
@@ -20,15 +20,71 @@ void ANSCustomFS::ResetDetectedArea() {
}
void ANSCustomFS::UpdatePriorityRegion(const cv::Mat& frame)
{
// divideImage caches geometry by frame size — it's cheap when the size is stable.
std::vector<ImageSection> sections = divideImage(frame);
int lowestPriority = getLowestPriorityRegion();
if (_currentPriority > lowestPriority || _currentPriority == 0) {
if (cachedSections.empty()) {
_currentPriority = 0;
return;
}
const int lowestPriority = getLowestPriorityRegion();
if (_currentPriority == 0 || _currentPriority >= lowestPriority) {
// Start of a new scan cycle — re-rank sections by warm-HSV pixel count.
// This steers the first-pass scan straight to the likely fire regions
// (reduces "late detection" compared to the old distance-to-center order).
RankCachedSectionsByWarmColor(frame);
_currentPriority = getHighestPriorityRegion();
}
else {
_currentPriority++;
}
}
void ANSCustomFS::RankCachedSectionsByWarmColor(const cv::Mat& frame)
{
if (cachedSections.empty() || frame.empty()) return;
try {
cv::Mat hsv;
cv::cvtColor(frame, hsv, cv::COLOR_BGR2HSV);
// Warm color = red / orange / yellow hues with enough saturation and brightness.
// OpenCV H is 0..179, so we cover the red wrap with two ranges.
cv::Mat mask1, mask2, warmMask;
cv::inRange(hsv,
cv::Scalar(0, 100, 150), cv::Scalar(30, 255, 255), mask1);
cv::inRange(hsv,
cv::Scalar(160, 100, 150), cv::Scalar(180, 255, 255), mask2);
warmMask = mask1 | mask2;
const cv::Rect frameRect(0, 0, frame.cols, frame.rows);
std::vector<std::pair<int, int>> scored; // (warmCount, sectionIndex)
scored.reserve(cachedSections.size());
for (size_t i = 0; i < cachedSections.size(); ++i) {
const cv::Rect safe = cachedSections[i].region & frameRect;
int count = 0;
if (safe.area() > 0) {
count = cv::countNonZero(warmMask(safe));
}
scored.emplace_back(count, static_cast<int>(i));
}
// Sort descending by warm count; tie-break by distance-to-center (original order).
std::stable_sort(scored.begin(), scored.end(),
[](const std::pair<int, int>& a, const std::pair<int, int>& b) {
return a.first > b.first;
});
// Rewrite priorities 1..N into cachedSections so getRegionByPriority picks warmest first.
for (size_t rank = 0; rank < scored.size(); ++rank) {
cachedSections[scored[rank].second].priority = static_cast<int>(rank + 1);
}
}
catch (const cv::Exception&) {
// On failure, leave existing priorities untouched (fallback to prior order).
}
}
int ANSCustomFS::CalculateOptimalCropSize(const cv::Mat& frame) const {
int maxDim = std::max(frame.cols, frame.rows);
if (maxDim > 1920) return 640;
@@ -58,16 +114,22 @@ void ANSCustomFS::ResetDetectionState() {
_isFireNSmokeDetected = false;
_trackHistory.clear();
}
// --- Tracker-based voting functions ---
// --- Tracker-based voting functions (dual-path: high-conf + low-conf) ---
void ANSCustomFS::UpdateTrackHistory(int trackId, int classId, const cv::Rect& bbox,
float confidence, double vMean) {
const int isHighConf = (confidence >= HIGH_CONF_THRESHOLD) ? 1 : 0;
void ANSCustomFS::UpdateTrackHistory(int trackId, int classId, const cv::Rect& bbox) {
auto it = _trackHistory.find(trackId);
if (it == _trackHistory.end()) {
TrackRecord record;
record.trackId = trackId;
record.classId = classId;
record.bboxHistory.push_back(bbox);
record.detectedCount = 1;
record.highConfHits.push_back(isHighConf);
record.vMeanHistory.push_back(vMean);
record.detectedCount = isHighConf;
record.lowConfDetectedCount = 1;
record.totalFrames = 1;
record.confirmed = false;
_trackHistory[trackId] = std::move(record);
@@ -75,16 +137,23 @@ void ANSCustomFS::UpdateTrackHistory(int trackId, int classId, const cv::Rect& b
else {
auto& record = it->second;
record.bboxHistory.push_back(bbox);
record.detectedCount++;
record.highConfHits.push_back(isHighConf);
record.vMeanHistory.push_back(vMean);
if (isHighConf) record.detectedCount++;
record.lowConfDetectedCount++;
record.totalFrames++;
// Slide the window: keep only VOTE_WINDOW entries in bbox history
// Slide the window: keep only VOTE_WINDOW entries in parallel deques
while (static_cast<int>(record.bboxHistory.size()) > VOTE_WINDOW) {
record.bboxHistory.pop_front();
record.detectedCount = std::max(0, record.detectedCount - 1);
const int oldHit = record.highConfHits.front();
record.highConfHits.pop_front();
record.vMeanHistory.pop_front();
if (oldHit == 1) record.detectedCount = std::max(0, record.detectedCount - 1);
record.lowConfDetectedCount = std::max(0, record.lowConfDetectedCount - 1);
}
// Update confirmed status
// Update confirmed status (high-conf path)
if (record.detectedCount >= VOTE_THRESHOLD) {
record.confirmed = true;
}
@@ -97,6 +166,39 @@ bool ANSCustomFS::IsTrackConfirmed(int trackId) const {
return it->second.detectedCount >= VOTE_THRESHOLD;
}
bool ANSCustomFS::IsTrackLowConfirmed(int trackId) const {
auto it = _trackHistory.find(trackId);
if (it == _trackHistory.end()) return false;
// Low-conf path requires more total hits than the high-conf window would need
// (since we accept weaker detections, we compensate with more votes)
return it->second.lowConfDetectedCount >= LOW_VOTE_THRESHOLD;
}
bool ANSCustomFS::HasFireFlicker(int trackId) const {
auto it = _trackHistory.find(trackId);
if (it == _trackHistory.end()) return false;
const auto& hist = it->second.vMeanHistory;
if (static_cast<int>(hist.size()) < FLICKER_MIN_SAMPLES) return false;
// Compute mean
double sum = 0.0;
for (double v : hist) sum += v;
const double mean = sum / static_cast<double>(hist.size());
// Compute std-dev
double sqSum = 0.0;
for (double v : hist) {
const double d = v - mean;
sqSum += d * d;
}
const double stddev = std::sqrt(sqSum / static_cast<double>(hist.size()));
// Real fire flickers at ~3–10 Hz, driving measurable luma variance.
// Sunlight reflections, static bright surfaces, and highlights do not.
return stddev > FLICKER_V_STD_THRESHOLD;
}
bool ANSCustomFS::HasBboxMovement(int trackId) const {
auto it = _trackHistory.find(trackId);
if (it == _trackHistory.end()) return false;
@@ -140,17 +242,26 @@ void ANSCustomFS::AgeTracks(const std::unordered_set<int>& detectedTrackIds) {
// Track was NOT detected this frame
it->second.totalFrames++;
// Remove stale tracks that haven't been seen recently
// Remove stale tracks that haven't been seen recently (both paths empty)
if (it->second.totalFrames > VOTE_WINDOW &&
it->second.detectedCount == 0) {
it->second.detectedCount == 0 &&
it->second.lowConfDetectedCount == 0) {
it = _trackHistory.erase(it);
continue;
}
// Age out the sliding window (add a "miss" frame)
// Age out the sliding window (add a "miss" frame) — drop oldest from all parallel deques
if (static_cast<int>(it->second.bboxHistory.size()) >= VOTE_WINDOW) {
it->second.bboxHistory.pop_front();
it->second.detectedCount = std::max(0, it->second.detectedCount - 1);
if (!it->second.highConfHits.empty()) {
const int oldHit = it->second.highConfHits.front();
it->second.highConfHits.pop_front();
if (oldHit == 1) it->second.detectedCount = std::max(0, it->second.detectedCount - 1);
}
if (!it->second.vMeanHistory.empty()) {
it->second.vMeanHistory.pop_front();
}
it->second.lowConfDetectedCount = std::max(0, it->second.lowConfDetectedCount - 1);
}
}
++it;
@@ -256,28 +367,55 @@ std::vector<ANSCENTER::Object> ANSCustomFS::FindNewDetectedArea(
return output;
}
// Find best detection and refine area
// Find best detection and refine area.
// Two-tier candidacy:
// 1) High-conf (>= DETECTION_CONFIDENCE_THRESHOLD) — latches ROI and emits immediately.
// 2) Low-conf fire with fire-color (>= LOW_CONF_FIRE_THRESHOLD) — latches ROI only,
// so ProcessExistingDetectedArea can run voting next frame without false positives
// from initial single-frame emission.
float maxScore = 0.0f;
ANSCENTER::Object* bestDetection = nullptr;
bool bestIsHighConf = false;
for (auto& detectedObj : detectedObjects) {
detectedObj.box.x += _detectedArea.x;
detectedObj.box.y += _detectedArea.y;
detectedObj.cameraId = camera_id;
if (detectedObj.confidence > DETECTION_CONFIDENCE_THRESHOLD &&
IsFireOrSmoke(detectedObj.classId, detectedObj.confidence) &&
detectedObj.confidence > maxScore) {
if (!IsFireOrSmoke(detectedObj.classId, detectedObj.confidence)) continue;
maxScore = detectedObj.confidence;
bestDetection = &detectedObj;
const bool isHighConf = (detectedObj.confidence > DETECTION_CONFIDENCE_THRESHOLD);
const bool isLowConfFire =
(detectedObj.classId == 0) && (detectedObj.confidence >= LOW_CONF_FIRE_THRESHOLD);
if (isHighConf) {
// Prefer high-conf; always overrides a low-conf candidate
if (!bestIsHighConf || detectedObj.confidence > maxScore) {
maxScore = detectedObj.confidence;
bestDetection = &detectedObj;
bestIsHighConf = true;
}
}
else if (isLowConfFire && !bestIsHighConf) {
// Gate low-conf candidates on fire-color presence in the bbox
if (!IsFireDetected(frame, detectedObj.box)) continue;
if (detectedObj.confidence > maxScore) {
maxScore = detectedObj.confidence;
bestDetection = &detectedObj;
// bestIsHighConf stays false
}
}
}
if (bestDetection != nullptr) {
RefineDetectedArea(frame, *bestDetection);
output.push_back(*bestDetection);
UpdatePositiveDetection();
if (bestIsHighConf) {
// Fast path: emit the first-frame detection as before
output.push_back(*bestDetection);
UpdatePositiveDetection();
}
// Low-conf path: commit ROI only. Voting in ProcessExistingDetectedArea
// will decide over subsequent frames whether to emit.
}
else {
ResetDetectedArea();
@@ -514,9 +652,12 @@ bool ANSCustomFS::Initialize(const std::string& modelDirectory, float detectionS
std::string licenseKey = "";
std::string motionDetectorLabels;
// Load detector model (fire/smoke detector)
float detScoreThreshold = _detectionScoreThreshold;
float detConfThreshold = 0.5f;
// Load detector model (fire/smoke detector).
// Floor thresholds at LOW_CONF_FIRE_THRESHOLD so the detector emits low-confidence
// detections that the dual-path voting in ProcessExistingDetectedArea can evaluate.
// The user-facing _detectionScoreThreshold is still enforced in code.
float detScoreThreshold = LOW_CONF_FIRE_THRESHOLD;
float detConfThreshold = LOW_CONF_FIRE_THRESHOLD;
float detNMSThreshold = 0.5f;
int detResult = _detector->LoadModelFromFolder(
licenseKey.c_str(),
@@ -621,53 +762,6 @@ cv::Rect ANSCustomFS::GenerateMinimumSquareBoundingBox(const std::vector<ANSCENT
return cv::Rect(0, 0, minSize, minSize);
}
}
bool ANSCustomFS::detectStaticFire(std::deque<cv::Mat>& frameQueue) {
return false;
if (frameQueue.size() < 10) return false;
double totalFlow = 0.0;
int count = 0;
for (size_t i = 2; i < frameQueue.size(); i += 3) {
cv::Mat prevGray, currGray;
cv::resize(frameQueue[i - 2], prevGray, cv::Size(), 0.5, 0.5);
cv::resize(frameQueue[i], currGray, cv::Size(), 0.5, 0.5);
cv::cvtColor(prevGray, prevGray, cv::COLOR_BGR2GRAY);
cv::cvtColor(currGray, currGray, cv::COLOR_BGR2GRAY);
std::vector<cv::Point2f> prevCorners, currCorners;
cv::goodFeaturesToTrack(prevGray, prevCorners, 100, 0.01, 10);
if (prevCorners.empty()) continue;
std::vector<uchar> status;
std::vector<float> err;
cv::calcOpticalFlowPyrLK(prevGray, currGray, prevCorners, currCorners, status, err);
double avgMotion = 0.0;
int validPoints = 0;
for (size_t j = 0; j < prevCorners.size(); j++) {
if (status[j]) {
double dx = currCorners[j].x - prevCorners[j].x;
double dy = currCorners[j].y - prevCorners[j].y;
avgMotion += std::sqrt(dx * dx + dy * dy);
validPoints++;
}
}
if (validPoints > 0) avgMotion /= validPoints;
totalFlow += avgMotion;
count++;
}
double avgMotion = (count > 0) ? totalFlow / count : 0;
if (avgMotion < 0.5) {
return true;
}
return false;
}
bool ANSCustomFS::detectScreenFlicker(const std::vector<cv::Mat>& frames) {
if (frames.size() < 10) return false;
@@ -918,16 +1012,15 @@ std::vector<ANSCustomFS::ImageSection> ANSCustomFS::divideImage(const cv::Mat& i
return cachedSections;
}
int ANSCustomFS::getHighestPriorityRegion() {
if (!cachedSections.empty()) {
return cachedSections.front().priority;
}
return 0;
// Priorities are always assigned as 1..N (N = number of sections), so the highest
// (most important) priority is 1 whenever we have any sections. Returning a literal
// keeps this correct when RankCachedSectionsByWarmColor rewrites priorities without
// reordering cachedSections.
return cachedSections.empty() ? 0 : 1;
}
int ANSCustomFS::getLowestPriorityRegion() {
if (!cachedSections.empty()) {
return cachedSections.back().priority;
}
return 0;
// Lowest priority (least important) is N, the total section count.
return static_cast<int>(cachedSections.size());
}
cv::Rect ANSCustomFS::getRegionByPriority(int priority) {
for (const auto& section : cachedSections) {
@@ -993,7 +1086,14 @@ std::vector<CustomObject> ANSCustomFS::RunInference(const cv::Mat& input, const
}
}
// Stage A: Process existing detected area with tracker-based voting
// Stage A: Process existing detected area with dual-path tracker-based voting.
//
// Dual-path design addresses the "small early fire" failure mode:
// HIGH-conf fast path: conf >= 0.5, 8-of-15 frames, gated by (movement OR flicker).
// LOW-conf slow path: conf >= 0.25, 6-of-15 frames, fire-class only,
// gated by (flicker AND fire-color present).
// The flicker gate uses temporal std-dev of HSV V inside the tracked bbox —
// real fire oscillates, sunlight reflections do not.
std::vector<ANSCENTER::Object> ANSCustomFS::ProcessExistingDetectedArea(
const cv::Mat& frame,
const std::string& camera_id,
@@ -1014,6 +1114,14 @@ std::vector<ANSCENTER::Object> ANSCustomFS::ProcessExistingDetectedArea(
return output;
}
// Precompute full-frame HSV once so we can sample V per bbox cheaply.
cv::Mat frameHsv;
cv::cvtColor(frame, frameHsv, cv::COLOR_BGR2HSV);
// COCO filter is expensive — run it at most once per frame and reuse.
bool excludedComputed = false;
std::vector<ANSCENTER::Object> excludedObjects;
// Collect detected track IDs this frame for aging
std::unordered_set<int> detectedTrackIds;
@@ -1028,18 +1136,32 @@ std::vector<ANSCENTER::Object> ANSCustomFS::ProcessExistingDetectedArea(
continue;
}
// 2. Confidence check — fire >= threshold, smoke >= smoke threshold
const bool isValidFire = (detectedObj.classId == 0) && (detectedObj.confidence >= _detectionScoreThreshold);
const bool isValidSmoke = (detectedObj.classId == 2) && (detectedObj.confidence >= _smokeDetetectionThreshold);
// 2. Confidence gate — dual-path entry:
// - fire (class 0) at >= LOW_CONF_FIRE_THRESHOLD enters the low-conf path
// - fire at >= _detectionScoreThreshold also enters the high-conf path
// - smoke (class 2) still requires SmokeScore threshold (high-conf only)
const bool passesLowConfFire =
(detectedObj.classId == 0) && (detectedObj.confidence >= LOW_CONF_FIRE_THRESHOLD);
const bool isValidFire =
(detectedObj.classId == 0) && (detectedObj.confidence >= _detectionScoreThreshold);
const bool isValidSmoke =
(detectedObj.classId == 2) && (detectedObj.confidence >= _smokeDetetectionThreshold);
if (!isValidFire && !isValidSmoke) {
if (!isValidFire && !isValidSmoke && !passesLowConfFire) {
continue;
}
// 3. Update track history with this detection
int trackId = detectedObj.trackId;
// 3. Sample mean HSV V inside the bbox for the flicker deque
cv::Rect safeBox = detectedObj.box & cv::Rect(0, 0, frame.cols, frame.rows);
double vMean = 0.0;
if (safeBox.area() > 0) {
vMean = cv::mean(frameHsv(safeBox))[2];
}
// 4. Update track history with this detection
const int trackId = detectedObj.trackId;
detectedTrackIds.insert(trackId);
UpdateTrackHistory(trackId, detectedObj.classId, detectedObj.box);
UpdateTrackHistory(trackId, detectedObj.classId, detectedObj.box, detectedObj.confidence, vMean);
#ifdef FNS_DEBUG
// Draw detection with track info
@@ -1047,27 +1169,51 @@ std::vector<ANSCENTER::Object> ANSCustomFS::ProcessExistingDetectedArea(
cv::rectangle(draw, detectedObj.box, color, 2);
auto trackIt = _trackHistory.find(trackId);
if (trackIt != _trackHistory.end()) {
std::string label = "T" + std::to_string(trackId) + " " +
std::string label = "T" + std::to_string(trackId) + " H" +
std::to_string(trackIt->second.detectedCount) + "/" +
std::to_string(VOTE_THRESHOLD);
std::to_string(VOTE_THRESHOLD) + " L" +
std::to_string(trackIt->second.lowConfDetectedCount) + "/" +
std::to_string(LOW_VOTE_THRESHOLD);
cv::putText(draw, label,
cv::Point(detectedObj.box.x, detectedObj.box.y - 10),
cv::FONT_HERSHEY_SIMPLEX, 0.5, color, 2);
}
#endif
// 4. Voting check — require consistent detection across frames
if (!IsTrackConfirmed(trackId)) {
// 5. Voting — which path (if any) confirmed this track?
const bool highConfirmed = IsTrackConfirmed(trackId);
const bool lowConfirmed = IsTrackLowConfirmed(trackId);
if (!highConfirmed && !lowConfirmed) {
continue;
}
// 5. Movement check — verify bounding box is changing (not static false positive)
if (!HasBboxMovement(trackId)) {
continue;
// 6. Gate: movement / flicker / color based on path
const bool hasFlicker = HasFireFlicker(trackId);
const bool hasMovement = HasBboxMovement(trackId);
if (highConfirmed) {
// High-conf path: sunlight FP kill requires evidence of temporal variation
// — either spatial (bbox drift) OR luma flicker is enough.
// This replaces the old movement-only gate which rejected small stationary fires.
if (!hasMovement && !hasFlicker) {
continue;
}
}
else {
// Low-conf-only path: stricter gate to suppress noise
// * fire class only (smoke is too easily confused at low conf)
// * require flicker (not just drift)
// * require fire-color HSV in the bbox
if (detectedObj.classId != 0) continue;
if (!hasFlicker) continue;
if (!IsFireDetected(frame, detectedObj.box)) continue;
}
// 6. COCO filter — exclude detections that overlap with known non-fire objects
std::vector<ANSCENTER::Object> excludedObjects = FindExcludedObjects(frame, camera_id, draw);
// 7. COCO filter — exclude detections that overlap with known non-fire objects
if (!excludedComputed) {
excludedObjects = FindExcludedObjects(frame, camera_id, draw);
excludedComputed = true;
}
if (!excludedObjects.empty() && IsOverlapping(detectedObj, excludedObjects, 0)) {
// Detection overlaps with a known object — not fire/smoke
_realFireCheck = std::max(0, _realFireCheck - 1);
@@ -1093,6 +1239,13 @@ std::vector<ANSCENTER::Object> ANSCustomFS::ProcessExistingDetectedArea(
}
void ANSCustomFS::AddConfirmedDetection(ANSCENTER::Object& detectedObj, std::vector<ANSCENTER::Object>& output) {
// A detection that passed the dual voting + flicker + color gates is a real positive.
// ConvertToCustomObjects() downstream filters by _detectionScoreThreshold, which would
// otherwise drop low-conf fires even after they've been confirmed. Bump the confidence
// to the threshold so the confirmed detection reaches the caller.
if (detectedObj.confidence < _detectionScoreThreshold) {
detectedObj.confidence = _detectionScoreThreshold;
}
output.push_back(std::move(detectedObj));
_isFireNSmokeDetected = true;
_retainDetectedArea = 0;
@@ -20,15 +20,24 @@ class CUSTOM_API ANSCustomFS : public IANSCustomClass
int trackId{ 0 };
int classId{ 0 }; // fire=0, smoke=2
std::deque<cv::Rect> bboxHistory; // bounding box history within window
int detectedCount{ 0 }; // frames detected in sliding window
std::deque<int> highConfHits; // parallel: 1 if >=HIGH_CONF_THRESHOLD, else 0
std::deque<double> vMeanHistory; // parallel: mean HSV V inside bbox (for flicker)
int detectedCount{ 0 }; // high-conf hits in sliding window
int lowConfDetectedCount{ 0 }; // total hits (any conf >= LOW_CONF_FIRE_THRESHOLD)
int totalFrames{ 0 }; // total frames since track appeared
bool confirmed{ false }; // passed voting threshold
bool confirmed{ false }; // passed high-conf voting threshold
};
// Voting mechanism constants
static constexpr int VOTE_WINDOW = 15;
static constexpr int VOTE_THRESHOLD = 8;
// Dual-path voting mechanism constants
static constexpr int VOTE_WINDOW = 15; // sliding window size (frames)
static constexpr int VOTE_THRESHOLD = 8; // high-conf fast path (>=0.5)
static constexpr int LOW_VOTE_THRESHOLD = 6; // low-conf slow path (>=0.25 + gates)
static constexpr float HIGH_CONF_THRESHOLD = 0.5f; // boundary between low/high conf
static constexpr float LOW_CONF_FIRE_THRESHOLD = 0.25f; // detector floor for small-fire path
static constexpr float BBOX_CHANGE_THRESHOLD = 0.05f;
// V-channel flicker gate: real fire oscillates in luma; sunlight does not
static constexpr double FLICKER_V_STD_THRESHOLD = 3.0;
static constexpr int FLICKER_MIN_SAMPLES = 6;
private:
using ANSLIBPtr = std::unique_ptr<ANSCENTER::ANSLIB, decltype(&ANSCENTER::ANSLIB::Destroy)>;
@@ -96,7 +105,6 @@ private:
cv::Rect GenerateMinimumSquareBoundingBox(const std::vector<ANSCENTER::Object>& detectedObjects, int minSize = 640);
void UpdateNoDetectionCondition();
bool detectStaticFire(std::deque<cv::Mat>& frameQueue);
bool detectScreenFlicker(const std::vector<cv::Mat>& frames);
bool detectReflection(const cv::Mat& frame);
bool MajorityColourInFrame(cv::Mat frame, Range range, float area_threshold);
@@ -136,11 +144,16 @@ private:
int getLowestPriorityRegion();
cv::Rect getRegionByPriority(int priority);
// Tracker-based voting methods
void UpdateTrackHistory(int trackId, int classId, const cv::Rect& bbox);
bool IsTrackConfirmed(int trackId) const;
// Tracker-based voting methods (dual path: high-conf fast + low-conf slow)
void UpdateTrackHistory(int trackId, int classId, const cv::Rect& bbox, float confidence, double vMean);
bool IsTrackConfirmed(int trackId) const; // high-conf path
bool IsTrackLowConfirmed(int trackId) const; // low-conf path (fire only)
bool HasBboxMovement(int trackId) const;
bool HasFireFlicker(int trackId) const; // V-channel temporal std-dev gate
void AgeTracks(const std::unordered_set<int>& detectedTrackIds);
// Warm-color priority scan: re-rank cached sections by HSV warm-pixel count
void RankCachedSectionsByWarmColor(const cv::Mat& frame);
std::vector<ANSCENTER::Object> FindNewDetectedArea(
const cv::Mat& frame,
const std::string& camera_id, cv::Mat& draw);
+4 -1
View File
@@ -32,6 +32,7 @@ int FireNSmokeDetection() {
//std::string videoFilePath = "C:\\Programs\\FireTest\\HFire2.mp4"; // failed as camera is moving
//std::string videoFilePath = "C:\\Programs\\DemoAssets\\Videos\\FireNSmoke\\E112 v4-2.mp4"; // failed white smoke low resolution cam
std::cout << "\n*** Start ***" << std::endl;
std::vector<std::string> classes;
ANSCustomFS detector;
std::string labelMap;
@@ -123,5 +124,7 @@ int FireNSmokeDetection() {
}
int main() {
return FireNSmokeDetection();
std::cout << "\n*** FireNSmokeDetection ***" << std::endl;
FireNSmokeDetection();
return 0;
}