ANSCENTER/ANSCORE
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove unused files

Browse Source
This commit is contained in:
Tuan Nghia Nguyen
2026-04-12 05:39:36 +10:00
parent 257145c429
commit 27083a6530
3 changed files with 6 additions and 1493 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
.claude/settings.local.json
View File

@@ -95,7 +95,12 @@
"mcp__desktop-commander__start_search",
"mcp__desktop-commander__get_more_search_results",
"mcp__desktop-commander__list_searches",
"Bash(grep -oE \"Faulting[^<]{1,500}|APPLICATION CRASHING[^<]{1,300}|EventID[^>]*>1000[^<]*|ExceptionCode[^<]{1,100}|onnxruntime[^<]{1,300}\" \"C:\\\\Users\\\\nghia\\\\Downloads\\\\Evenlog.xml\")"
"Bash(grep -oE \"Faulting[^<]{1,500}|APPLICATION CRASHING[^<]{1,300}|EventID[^>]*>1000[^<]*|ExceptionCode[^<]{1,100}|onnxruntime[^<]{1,300}\" \"C:\\\\Users\\\\nghia\\\\Downloads\\\\Evenlog.xml\")",
"mcp__desktop-commander__start_process",
"Bash(grep -oE \"Faulting[^<]{1,600}|ExceptionCode[^<]{1,100}|FaultingOffset[^<]{1,60}|FaultingModule[^<]{1,200}\" \"C:\\\\Users\\\\nghia\\\\Downloads\\\\Evenlog2.xml\")",
"Bash(grep -aoE \"Faulting[^<]{1,600}\" \"C:\\\\Users\\\\nghia\\\\Downloads\\\\Evenlog2.xml\")",
"Bash(where python:*)",
"Bash(grep -aoE \"Faulting[^<]{1,700}|ExceptionCode'[^<]{1,60}|FaultingOffset'[^<]{1,60}\" 'C:/Users/nghia/Downloads/Evenlog3.xml')"
]
}
}

1197
modules/ANSODEngine/ANSFireNSmoke.cpp
View File

File diff suppressed because it is too large Load Diff

295
modules/ANSODEngine/ANSFireNSmoke.h
View File

@@ -1,295 +0,0 @@
#ifndef ANSFIRENSMOKE_H
#define ANSFIRENSMOKE_H
#pragma once
#include "ANSEngineCommon.h"
#include <opencv2/opencv.hpp>
#include <opencv2/dnn.hpp>
#include <openvino/openvino.hpp>
#include "ANSYOLOV10OVOD.h"
#include "ANSYOLOV10RTOD.h"
namespace ANSCENTER
{
class ImageProcessor {
const int MAX_QUEUE_SIZE = 10;
const int THRESHOLD = 8;
public:
// Add image to the queue and process if queue has 10 images
std::vector<cv::Rect> addImageToQueue(const cv::Mat& image) {
width = image.cols;
height = image.rows;
// Check if queue size is already 10, if so, remove the oldest image
if (imageQueue.size() == MAX_QUEUE_SIZE) {
imageQueue.pop();
}
// Add the new image to the queue
imageQueue.push(image.clone());
// Process images if we have exactly 10 images in the queue
if (imageQueue.size() == MAX_QUEUE_SIZE) {
return processQueueImages();
}
// Return an empty vector if not yet ready to process
return std::vector<cv::Rect>();
}
private:
int width, height;
std::queue<cv::Mat> imageQueue;
// Sum all images in the queue, create a mask, and return array of bounding rectangles
std::vector<cv::Rect> processQueueImages() {
// Initialize the sum image with zeros
cv::Mat sumImage = cv::Mat::zeros(height, width, CV_32FC1);
// Use a temporary queue to preserve the original images
std::queue<cv::Mat> tempQueue = imageQueue;
// Sum up all images in the queue
while (!tempQueue.empty()) {
cv::Mat img = tempQueue.front();
tempQueue.pop();
// Accumulate image pixels in sumImage
sumImage += img;
}
// Threshold the summed image to create a binary mask
cv::Mat mask;
cv::threshold(sumImage, mask, THRESHOLD, 1, cv::THRESH_BINARY);
// Convert mask to 8-bit to find contours
mask.convertTo(mask, CV_8UC1);
// Find contours on the mask
std::vector<std::vector<cv::Point>> contours;
cv::findContours(mask, contours, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_SIMPLE);
// Extract bounding rectangles for each contour
std::vector<cv::Rect> boundingRects;
for (const auto& contour : contours) {
cv::Rect boundingRect = cv::boundingRect(contour);
boundingRects.push_back(boundingRect);
}
return boundingRects;
}
};
class GLCM {
public:
explicit GLCM(const std::string& channel) : channel(channel) {}
std::vector<cv::Mat> getGLCM(const cv::Mat& imageChannel,
const std::vector<int>& distances = { 5 },
const std::vector<float>& angles = { 0.0f },// { 0.0f, CV_PI / 4.0f, CV_PI / 2.0f, 3.0f * CV_PI / 4.0f },
int levels = 256,
bool symmetric = false,
bool normed = false) {
cv::Mat imageChannel8;
imageChannel.convertTo(imageChannel8, CV_8U);
return graycomatrix(imageChannel8, distances, angles, levels, symmetric, normed);
}
void getStockPropFromGLCM(const std::vector<cv::Mat>& glcmMatrices, const std::string& prop) {
auto featureVector = graycoprops(glcmMatrices, prop);
for (size_t i = 0; i < featureVector.size(); ++i) {
props[prop + std::to_string(i + 1) + "_channel" + channel] = featureVector[i];
}
}
const std::map<std::string, double>& getProps() const {
return props;
}
private:
std::string channel;
std::map<std::string, double> props;
void normalizeGLCM(cv::Mat& glcm);
std::vector<cv::Mat> graycomatrix(const cv::Mat& image,
const std::vector<int>& distances,
const std::vector<float>& angles,
int levels = 256,
bool symmetric = false,
bool normed = false);
std::vector<double> graycoprops(const std::vector<cv::Mat>& glcmMatrices, const std::string& property);
};
class HaralickFeatureExtractor {
public:
HaralickFeatureExtractor() {
}
~HaralickFeatureExtractor()
{
}
void Init(const std::string& colourSpace = "RGB",
const std::vector<std::string>& properties = { "energy","homogeneity","dissimilarity","contrast"})
{
props = properties;
for (char channel : colourSpace) {
channels.push_back(std::string(1, channel));
}
}
cv::Mat resizeWithMinAspectRatio(const cv::Mat& inputImage, int minSize) {
// Get original dimensions
int originalWidth = inputImage.cols;
int originalHeight = inputImage.rows;
if ((originalWidth > minSize) && (originalHeight > minSize))return inputImage;
// Calculate aspect ratio
float aspectRatio = static_cast<float>(originalWidth) / static_cast<float>(originalHeight);
// Calculate new dimensions based on the minimum size
int newWidth, newHeight;
if (originalWidth > originalHeight) {
newHeight = minSize;
newWidth = static_cast<int>(minSize * aspectRatio);
}
else {
newWidth = minSize;
newHeight = static_cast<int>(minSize / aspectRatio);
}
// Resize the image
cv::Mat resizedImage;
cv::resize(inputImage, resizedImage, cv::Size(newWidth, newHeight));
return resizedImage;
}
std::vector<double> createFeatureVector(const cv::Mat& inputImage) {
//0. Resize the image to a minimum size
cv::Mat frame = resizeWithMinAspectRatio(inputImage, 200);// min is 20
//1. Convert to RGB format if necessary
cv::Mat imageArray;
if (inputImage.channels() == 3) {
cv::cvtColor(frame, imageArray, cv::COLOR_BGR2RGB); // Convert BGR to RGB
}
else {
return std::vector<double>();
}
// Split the image into individual channels
std::vector<cv::Mat> imageChannels(3);
cv::split(imageArray, imageChannels);
// Initialize GLCM objects for each channel
GLCM glcmChannel0("R"); // Red channel
GLCM glcmChannel1("G"); // Green channel
GLCM glcmChannel2("B"); // Blue channel
// Calculate GLCM matrices for each channel
auto glcmChannel0Matx = glcmChannel0.getGLCM(imageChannels[0]);
auto glcmChannel1Matx = glcmChannel1.getGLCM(imageChannels[1]);
auto glcmChannel2Matx = glcmChannel2.getGLCM(imageChannels[2]);
// Compute properties for each channel
for (const auto& prop : props) {
glcmChannel0.getStockPropFromGLCM(glcmChannel0Matx, prop);
glcmChannel1.getStockPropFromGLCM(glcmChannel1Matx, prop);
glcmChannel2.getStockPropFromGLCM(glcmChannel2Matx, prop);
}
// Combine all properties into a single feature vector in the desired order
std::vector<double> featureVector;
// Iterate over channels first (R, G, B)
for (size_t channelIdx = 0; channelIdx < 3; ++channelIdx) {
const GLCM* glcmChannel = nullptr;
std::string channelName;
// Select the appropriate channel
if (channelIdx == 0) {
glcmChannel = &glcmChannel0;
channelName = "R";
}
else if (channelIdx == 1) {
glcmChannel = &glcmChannel1;
channelName = "G";
}
else if (channelIdx == 2) {
glcmChannel = &glcmChannel2;
channelName = "B";
}
// Retrieve properties for the selected channel
const auto& propsMap = glcmChannel->getProps();
// Iterate over properties for the current channel
for (const auto& prop : props) {
std::string key = prop + "1_channel" + channelName;
if (propsMap.find(key) != propsMap.end()) {
featureVector.push_back(propsMap.at(key));
}
}
}
frame.release();
return featureVector;
}
private:
std::vector<std::string> props;
std::vector<std::string> channels;
};
class ANSENGINE_API ANSFIRENSMOKE :public ANSODBase
{
public:
virtual bool Initialize(std::string licenseKey, ModelConfig modelConfig, const std::string& modelZipFilePath, const std::string& modelZipPassword, std::string& labelMap) override;
virtual bool LoadModel(const std::string& modelZipFilePath, const std::string& modelZipPassword) override;
virtual bool LoadModelFromFolder(std::string licenseKey, ModelConfig modelConfig, std::string modelName, std::string className,const std::string& modelFolder, std::string& labelMap)override;
bool OptimizeModel(bool fp16, std::string& optimizedModelFolder);
std::vector<Object> RunInference(const cv::Mat& input);
std::vector<Object> RunInference(const cv::Mat& input, const std::string& camera_id);
bool Destroy();
~ANSFIRENSMOKE();
private:
double _hsvThreshold;
std::vector<Range> _smoke_colour;
std::vector<Range> _fire_colour;
std::string _classifierModelPath;
ANSOYOLOV10OVOD _cpuObjectDetector;
ANSYOLOV10RTOD _gpuObjectDetector;
EngineType _engineType;
ImageProcessor _smokeImageProcessor;
ImageProcessor _fireImageProcessor;
ANNHUBClassifier _annhub;
const int SMOKE_THRESHOLD_SIZE = 4;
const int HISTORY_SIZE = 30;
const int MIN_MATCHES = 9;
const float IOU_THRESHOLD = 0.4;
const int MINIMUM_STABLE_DURATION = 30;
const float MAX_MOVEMENT = 40.0;
const float ALPHA = 0.7;
cv::Rect _detectedArea;// Area where fire and smoke are detected
cv::Rect _previousDetectedArea;// Area where fire and smoke are detected
int _retainDetectedArea{ 0 };
bool _isFireNSmokeDetected{ false };
bool _classifierInitialized{ false };
HaralickFeatureExtractor _extractor;
std::vector<std::pair<Object, int>> _persistent_detections;
std::deque<std::vector<Object>> _stablization_queue;
private:
bool MajorityColourInFrame(const cv::Mat frame, Range range, float area_threshold = 0.8);
bool MajorityColourInFrame(const cv::Mat frame, std::vector<Range> ranges, float area_threshold = 0.8);
bool DetectFireNSmokeColourInFrame(const cv::Mat& frame, const cv::Rect bBox, const std::vector<Range>& ranges, float area_threshold);
cv::Mat CreateBinaryImageWithRects(int width, int height, const std::vector<cv::Rect>& rects);
cv::Point2f CalculateCentroid(const std::vector<cv::Rect>& group);
cv::Point2f CalculateGroupCenter(const std::vector<cv::Rect>& group);
std::vector<cv::Rect> CreateCoveringMaskRects(const cv::Mat& image, const std::vector<cv::Rect>& maskRects, float maxDistance);
std::vector<Object> ProcecssDetection(const std::vector<Object>& detectedObjects, const std::string& camera_id, int threshold = 8);
cv::Rect CreateMinimumSquareBoundingBox(const std::vector<Object>& detectedObjects, int minSize = 640);
bool IsOverlap(const cv::Rect& target, const std::vector<Object>& rectArray);
bool IsFireDetected(const cv::Mat image, const cv::Rect bBox);
bool IsSmokeDetected(const cv::Mat image, const cv::Rect bBox);
float calculateIOU(const cv::Rect& box_a, const cv::Rect& box_b);
std::vector<Object> StablizeDetection(const std::vector<Object>& detectedObjects, const std::string& camera_id);
};
}
#endif