diff --git a/tests/ANSCV-UnitTest/CMakeLists.txt b/tests/ANSCV-UnitTest/CMakeLists.txt index 018baae..d24ba85 100644 --- a/tests/ANSCV-UnitTest/CMakeLists.txt +++ b/tests/ANSCV-UnitTest/CMakeLists.txt @@ -4,40 +4,63 @@ add_executable(ANSCV-UnitTest OpenCVTest.cpp ) -target_include_directories(ANSCV-UnitTest PRIVATE - ${CMAKE_SOURCE_DIR}/modules/ANSCV - ${CMAKE_SOURCE_DIR}/MediaClient - ${CMAKE_SOURCE_DIR}/MediaClient/media - ${CMAKE_SOURCE_DIR}/MediaClient/rtsp - ${CMAKE_SOURCE_DIR}/MediaClient/rtp - ${CMAKE_SOURCE_DIR}/MediaClient/bm - ${CMAKE_SOURCE_DIR}/MediaClient/http - ${CMAKE_SOURCE_DIR}/MediaClient/directx - ${CMAKE_SOURCE_DIR}/MediaClient/rtmp - ${CMAKE_SOURCE_DIR}/MediaClient/librtmp - ${CMAKE_SOURCE_DIR}/MediaClient/srt - ${CMAKE_SOURCE_DIR}/MediaClient/ffmpeg/include - ${CMAKE_SOURCE_DIR}/MediaClient/openssl/include - ${CMAKE_SOURCE_DIR}/MediaClient/libsrt/include - ${SHARED_INCLUDE_DIR} - ${ANSLIBS_DIR}/TurboJpeg - ${ANSLIBS_DIR}/QRCode +# ANSCV Console Test — headless smoke test (no GUI/camera/disk), prints +# PASS/FAIL per check and exits with the failure count. Built as its own +# executable so it does not collide with ANSCV-UnitTest's GUI main(). +add_executable(ANSCV-ConsoleTest + ConsoleTest.cpp ) -target_link_libraries(ANSCV-UnitTest - PRIVATE ANSCV - PRIVATE ANSLicensingSystem - PRIVATE anslicensing - PRIVATE labview - PRIVATE opencv - PRIVATE turbojpeg - PRIVATE zxing - PRIVATE CUDA::cudart - PRIVATE CUDA::nvjpeg -) - -if(WIN32) - target_link_libraries(ANSCV-UnitTest PRIVATE ${WIN_COMMON_LIBS}) +# ans_imshow.hpp lives outside the repo (shipped with ANSMIND). Default to the +# standard install location but allow overriding on other machines/CI via +# -DANSMIND_INCLUDE_DIR=. Warn (don't fail configure) if it's missing, so +# unrelated targets still build; ConsoleTest will then fail to compile clearly. +set(ANSMIND_INCLUDE_DIR "C:/ProgramData/ANSCENTER/ANSMIND" + CACHE PATH "Directory containing ans_imshow.hpp (shipped with ANSMIND)") +if(NOT EXISTS "${ANSMIND_INCLUDE_DIR}/ans_imshow.hpp") + message(WARNING + "ans_imshow.hpp not found in ANSMIND_INCLUDE_DIR='${ANSMIND_INCLUDE_DIR}'. " + "ANSCV-ConsoleTest will fail to compile. " + "Set -DANSMIND_INCLUDE_DIR= to the directory containing ans_imshow.hpp.") endif() -target_compile_definitions(ANSCV-UnitTest PRIVATE UNICODE _UNICODE) +foreach(_anscv_test ANSCV-UnitTest ANSCV-ConsoleTest) + target_include_directories(${_anscv_test} PRIVATE + ${CMAKE_SOURCE_DIR}/modules/ANSCV + ${CMAKE_SOURCE_DIR}/MediaClient + ${CMAKE_SOURCE_DIR}/MediaClient/media + ${CMAKE_SOURCE_DIR}/MediaClient/rtsp + ${CMAKE_SOURCE_DIR}/MediaClient/rtp + ${CMAKE_SOURCE_DIR}/MediaClient/bm + ${CMAKE_SOURCE_DIR}/MediaClient/http + ${CMAKE_SOURCE_DIR}/MediaClient/directx + ${CMAKE_SOURCE_DIR}/MediaClient/rtmp + ${CMAKE_SOURCE_DIR}/MediaClient/librtmp + ${CMAKE_SOURCE_DIR}/MediaClient/srt + ${FFMPEG_INCLUDE_DIR} # FFmpeg 8.1 (n8.1); was vendored MediaClient/ffmpeg/include 4.0.2 + ${CMAKE_SOURCE_DIR}/MediaClient/openssl/include + ${CMAKE_SOURCE_DIR}/MediaClient/libsrt/include + ${SHARED_INCLUDE_DIR} + ${ANSLIBS_DIR}/TurboJpeg + ${ANSLIBS_DIR}/QRCode + ${ANSMIND_INCLUDE_DIR} # ans_imshow.hpp (ConsoleTest.cpp) + ) + + target_link_libraries(${_anscv_test} + PRIVATE ANSCV + PRIVATE ANSLicensingSystem + PRIVATE anslicensing + PRIVATE labview + PRIVATE opencv + PRIVATE turbojpeg + PRIVATE zxing + PRIVATE CUDA::cudart + PRIVATE CUDA::nvjpeg + ) + + if(WIN32) + target_link_libraries(${_anscv_test} PRIVATE ${WIN_COMMON_LIBS}) + endif() + + target_compile_definitions(${_anscv_test} PRIVATE UNICODE _UNICODE) +endforeach() diff --git a/tests/ANSCV-UnitTest/ConsoleTest.cpp b/tests/ANSCV-UnitTest/ConsoleTest.cpp new file mode 100644 index 0000000..3857682 --- /dev/null +++ b/tests/ANSCV-UnitTest/ConsoleTest.cpp @@ -0,0 +1,380 @@ +// ANSCV Console Test +// ------------------------------------------------------------------ +// A headless (no GUI) smoke test for ANSCENTER::ANSOPENCV image ops plus an +// optional RTSP capture test (ANSCENTER::ANSRTSPClient). It prints a PASS/FAIL +// line per check so results are visible in a plain console (and in CI). +// Exit code == number of failed checks (0 == all OK). +// +// Usage: +// ANSCV-ConsoleTest.exe # image ops only (no camera needed) +// ANSCV-ConsoleTest.exe # image ops + headless RTSP capture +// ANSCV-ConsoleTest.exe +// ANSCV-ConsoleTest.exe +// When is given: +// /frames/NNNN.jpg full-res captured frames (MP4 input) +// /preview_NNNN.jpg downscaled previews for quick viewing +// /rtsp_clip.mp4 short clip (NVENC, via ANSCV ImagesToMP4HW) +// +// This is intentionally separate from ANSCV-UnitTest.cpp, whose main() +// opens OpenCV windows (cv::imshow) for the same RTSP stream. +#include "ANSOpenCV.h" +#include "ANSRTSP.h" +#include "ans_imshow.hpp" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef _WIN32 +# define NOMINMAX +# define WIN32_LEAN_AND_MEAN +# include +#endif + +using ANSCENTER::ANSOPENCV; +using ANSCENTER::ANSRTSPClient; +using ANSCENTER::DetectionObject; + +namespace { + +int g_pass = 0; +int g_fail = 0; + +// Report a single check. `detail` is appended for context (sizes, counts, ...). +void check(const std::string& name, bool ok, const std::string& detail = "") { + if (ok) { + ++g_pass; + std::cout << " [PASS] " << name; + } else { + ++g_fail; + std::cout << " [FAIL] " << name; + } + if (!detail.empty()) std::cout << " (" << detail << ")"; + std::cout << std::endl; +} + +std::string dims(const cv::Mat& m) { + return std::to_string(m.cols) + "x" + std::to_string(m.rows) + + " ch=" + std::to_string(m.channels()); +} + +// A 640x480 BGR test image: smooth gradient plus a few filled shapes so the +// transforms operate on something with real structure (not a flat color). +cv::Mat MakeTestImage(int w = 640, int h = 480) { + cv::Mat img(h, w, CV_8UC3); + for (int y = 0; y < h; ++y) { + for (int x = 0; x < w; ++x) { + img.at(y, x) = cv::Vec3b( + static_cast(x * 255 / w), + static_cast(y * 255 / h), + static_cast((x + y) * 255 / (w + h))); + } + } + cv::rectangle(img, cv::Rect(50, 50, 200, 150), cv::Scalar(0, 0, 255), -1); + cv::circle(img, cv::Point(450, 300), 80, cv::Scalar(0, 255, 0), -1); + return img; +} + +// Headless RTSP capture test. Connects to `url`, pulls up to `maxFrames` +// frames (or until `timeoutMs` elapses), and reports resolution, frame count, +// JPEG sizes, per-grab latency and approximate FPS. No GUI — every frame is +// reported as text. Bounded so it always terminates even if the camera is +// unreachable. Adds PASS/FAIL checks to the global tally. +void RtspConsoleTest(const std::string& url, int maxFrames, + const std::string& saveDir = "", int timeoutMs = 15000) { + std::cout << "-- RTSP capture --" << std::endl; + std::cout << "URL: " << url << std::endl; + // Give slow/high-res streams enough wall-clock to reach maxFrames. + timeoutMs = (std::max)(timeoutMs, maxFrames * 1000); + std::cout << "Grabbing up to " << maxFrames << " frames (timeout " + << timeoutMs << " ms)..." << std::endl; + + // When saving, full-res frames go into /frames (clean, zero-padded + // names) so the MP4 encoder globs only those; previews go into . + std::string framesDir; + if (!saveDir.empty()) { + framesDir = saveDir + "/frames"; + std::error_code ec; + std::filesystem::create_directories(framesDir, ec); + std::cout << "Saving frames to: " << saveDir << std::endl; + } + + ANSOPENCV::InitCameraNetwork(); + + ANSRTSPClient* client = nullptr; + // CreateANSRTSPHandle(handle, licenseKey, username, password, url). + // Credentials embedded in the URL → pass empty user/pass, matching the + // existing RSTPTestClient() usage. + int created = CreateANSRTSPHandle(&client, "", "", "", url.c_str()); + check("CreateANSRTSPHandle", client != nullptr, + "rc=" + std::to_string(created)); + if (client == nullptr) { + ANSOPENCV::DeinitCameraNetwork(); + return; + } + + StartRTSP(&client); + + int width = 0, height = 0; + int64_t pts = 0; + int frames = 0; + long long totalJpegBytes = 0; + long long totalGrabMs = 0; + int firstW = 0, firstH = 0; + int64_t firstPts = 0, lastPts = 0; + + const auto t0 = std::chrono::steady_clock::now(); + auto elapsedMs = [&] { + return std::chrono::duration_cast( + std::chrono::steady_clock::now() - t0).count(); + }; + + int polls = 0; + while (frames < maxFrames && elapsedMs() < timeoutMs) { + ++polls; + std::string jpeg; + const auto g0 = std::chrono::steady_clock::now(); + GetRTSPStrImage(&client, width, height, pts, jpeg); + const auto grabMs = std::chrono::duration_cast( + std::chrono::steady_clock::now() - g0).count(); + + if (jpeg.empty()) { + // No frame ready yet (connecting / between frames). Back off briefly. + std::this_thread::sleep_for(std::chrono::milliseconds(50)); + continue; + } + + if (frames == 0) { firstW = width; firstH = height; firstPts = pts; } + lastPts = pts; + ++frames; + totalJpegBytes += static_cast(jpeg.size()); + totalGrabMs += grabMs; + + // Optionally persist the frame so it can be viewed outside the console. + // The grabbed bytes are already a JPEG, so the full-res file is a direct + // dump (no re-encode). The preview is decoded + downscaled for quick view. + if (!saveDir.empty()) { + // Zero-pad to 4 digits (lexicographic sort == capture order) without + // snprintf: some included headers #define snprintf -> _snprintf. + std::string idx = std::to_string(frames); + if (idx.size() < 4) idx.insert(0, 4 - idx.size(), '0'); + // Full-res frame -> frames/ (MP4 input). Already JPEG: direct dump. + std::ofstream f(framesDir + "/" + idx + ".jpg", std::ios::binary); + f.write(jpeg.data(), static_cast(jpeg.size())); + f.close(); + // Downscaled preview -> saveDir (chat-friendly viewing). + std::vector buf(jpeg.begin(), jpeg.end()); + cv::Mat full = cv::imdecode(buf, cv::IMREAD_COLOR); + if (!full.empty()) { + const int previewW = 960; + cv::Mat preview; + cv::resize(full, preview, + cv::Size(previewW, full.rows * previewW / full.cols)); + cv::imwrite(saveDir + "/preview_" + idx + ".jpg", preview); + } + } + + // Report every frame for the first few, then every 10th to stay readable. + if (frames <= 5 || frames % 10 == 0) { + std::cout << " frame " << frames << ": " << width << "x" << height + << " pts=" << pts << " jpeg=" << jpeg.size() << "B" + << " grab=" << grabMs << "ms" << std::endl; + } + } + + const long long elapsed = elapsedMs(); + StopRTSP(&client); + ReleaseANSRTSPHandle(&client); + ANSOPENCV::DeinitCameraNetwork(); + + std::cout << " polls=" << polls << " frames=" << frames + << " elapsed=" << elapsed << "ms" << std::endl; + if (frames > 0) { + const double fps = elapsed > 0 ? frames * 1000.0 / elapsed : 0.0; + std::cout << " resolution=" << firstW << "x" << firstH + << " avgJpeg=" << (totalJpegBytes / frames) << "B" + << " avgGrab=" << (totalGrabMs / frames) << "ms" + << " ~fps=" << fps + << " ptsDelta=" << (lastPts - firstPts) << std::endl; + } + + check("RTSP received >=1 frame", frames > 0, + std::to_string(frames) + " frames in " + std::to_string(elapsed) + "ms"); + if (frames > 0) { + check("RTSP frame has valid resolution", firstW > 0 && firstH > 0, + std::to_string(firstW) + "x" + std::to_string(firstH)); + } + + // Encode the captured frames into a short MP4 clip using ANSCV's own + // hardware (NVENC) encoder, so the stream can actually be watched as video. + // maxWidth=1280 downscales the 4K stills to a manageable file; playback fps + // is fixed at 5 so a small burst yields a watchable clip. + if (!saveDir.empty() && frames >= 2) { + const std::string mp4Path = saveDir + "/rtsp_clip.mp4"; + const int playbackFps = 5; + std::cout << " encoding MP4 (" << frames << " frames -> " << mp4Path + << ", maxW=1280, " << playbackFps << " fps)..." << std::endl; + const int rc = ANSCV_ImagesToMP4HW_S(framesDir.c_str(), mp4Path.c_str(), + 1280, playbackFps); + bool ok = rc != 0 && std::filesystem::exists(mp4Path); + std::string detail = "rc=" + std::to_string(rc); + if (ok) { + const auto sz = std::filesystem::file_size(mp4Path); + detail += ", " + std::to_string(sz) + " bytes"; + } + check("RTSP frames encoded to MP4", ok, detail); + } +} + +} // namespace + +int main(int argc, char** argv) { + std::cout << "==== ANSCV Console Test ====" << std::endl; + + // Optional RTSP target. argv[1] = URL, argv[2] = max frames (default 60), + // argv[3] = directory to save captured frames into (optional). + const std::string rtspUrl = (argc > 1) ? argv[1] : ""; + const int rtspMaxFrames = (argc > 2) ? std::atoi(argv[2]) : 60; + const std::string rtspSaveDir = (argc > 3) ? argv[3] : ""; + + ANSOPENCV cv_; + const bool licensed = cv_.Init(""); // empty license key, matching existing tests + std::cout << "Init(\"\") license valid: " << (licensed ? "yes" : "no") << std::endl; + + const cv::Mat src = MakeTestImage(); + std::cout << "Source image: " << dims(src) << std::endl; + std::cout << "-- Geometry / resize --" << std::endl; + + { + cv::Mat out; + cv_.ImageResize(src, 320, 240, out); + check("ImageResize 320x240", out.cols == 320 && out.rows == 240, dims(out)); + } + { + cv::Mat out; + cv_.ImageResizeWithRatio(src, 320, out); + check("ImageResizeWithRatio width=320", out.cols == 320 && !out.empty(), dims(out)); + } + { + cv::Mat out = cv_.ImageResizeV2(src, 200); + check("ImageResizeV2 width=200", !out.empty() && out.cols == 200, dims(out)); + } + { + cv::Mat out = cv_.ImageCrop(src, cv::Rect(10, 20, 100, 80)); + check("ImageCrop 100x80", out.cols == 100 && out.rows == 80, dims(out)); + } + { + cv::Mat out = cv_.RotateImage(src, 90.0); + check("RotateImage 90deg", !out.empty(), dims(out)); + } + { + cv::Mat out = cv_.FlipImage(src, 1); // horizontal + check("FlipImage horizontal", out.size() == src.size() && !out.empty(), dims(out)); + } + { + // ShiftImage expands the canvas by |shiftX| x |shiftY| to keep all + // pixels after the translation (640+30, 480+40). + cv::Mat out = cv_.ShiftImage(src, 30, 40); + check("ShiftImage (30,40) expands canvas", + out.cols == src.cols + 30 && out.rows == src.rows + 40, dims(out)); + } + + std::cout << "-- Color / enhancement --" << std::endl; + { + cv::Mat out = cv_.ToGray(src); + check("ToGray -> 1 channel", out.channels() == 1 && !out.empty(), dims(out)); + } + { + cv::Mat out = cv_.ImageContrastEnhancement(src); + check("ImageContrastEnhancement", !out.empty(), dims(out)); + } + { + cv::Mat out = cv_.ImageWhiteBalance(src); + check("ImageWhiteBalance", !out.empty(), dims(out)); + } + { + cv::Mat out = cv_.ImageDarkEnhancement(src, 1.5); + check("ImageDarkEnhancement x1.5", !out.empty(), dims(out)); + } + + std::cout << "-- Noise augmentation --" << std::endl; + { + cv::Mat out = cv_.AddGaussianNoise(src, 0.0, 20.0); + check("AddGaussianNoise", out.size() == src.size() && !out.empty(), dims(out)); + } + { + cv::Mat out = cv_.AddSaltAndPepperNoise(src, 0.02); + check("AddSaltAndPepperNoise", out.size() == src.size() && !out.empty(), dims(out)); + } + { + cv::Mat out = cv_.AddSpeckleNoise(src, 0.1); + check("AddSpeckleNoise", out.size() == src.size() && !out.empty(), dims(out)); + } + + std::cout << "-- Encode --" << std::endl; + { + std::string bin = cv_.MatToBinaryData(src); + check("MatToBinaryData non-empty", !bin.empty(), + std::to_string(bin.size()) + " bytes"); + } + { + std::string b64 = cv_.MatToBase64(src); + check("MatToBase64 non-empty", !b64.empty(), + std::to_string(b64.size()) + " chars"); + } + + std::cout << "-- Parse / serialize --" << std::endl; + { + // GetBoundingBoxes parses a JSON object with a "results" array, each + // entry carrying x/y/width/height. + const std::string boxesJson = + R"({"results":[)" + R"({"x":10,"y":20,"width":30,"height":40},)" + R"({"x":100,"y":110,"width":50,"height":60}]})"; + std::vector boxes = cv_.GetBoundingBoxes(boxesJson); + bool ok = boxes.size() == 2 && + boxes[0] == cv::Rect(10, 20, 30, 40) && + boxes[1] == cv::Rect(100, 110, 50, 60); + check("GetBoundingBoxes parses 2 boxes", ok, + std::to_string(boxes.size()) + " boxes"); + } + { + std::vector dets(2); + dets[0].classId = 1; dets[0].className = "person"; + dets[0].confidence = 0.9f; dets[0].box = cv::Rect(10, 10, 40, 80); + dets[1].classId = 2; dets[1].className = "car"; + dets[1].confidence = 0.8f; dets[1].box = cv::Rect(60, 60, 100, 50); + std::string json = cv_.VectorDetectionToJsonString(dets); + check("VectorDetectionToJsonString non-empty", !json.empty(), + std::to_string(json.size()) + " chars"); + } + + if (!rtspUrl.empty()) { + RtspConsoleTest(rtspUrl, rtspMaxFrames, rtspSaveDir); + } else { + std::cout << "-- RTSP capture --" << std::endl; + std::cout << " (skipped: no RTSP URL given; pass one as the first " + "argument to run it)" << std::endl; + } + + std::cout << "============================" << std::endl; + std::cout << "Result: " << g_pass << " passed, " << g_fail << " failed." + << std::endl; + + // NOTE: at process exit one of the loaded DLLs throws a C++ exception + // during DllMain(PROCESS_DETACH) (observed exit code 0xE06D7363), + // regardless of test outcome. All test work is complete by this point, so + // force a deterministic exit code for CI. TerminateProcess is used because + // both return and quick_exit go through ExitProcess, which still triggers + // the faulty DLL-detach path; TerminateProcess skips it. + std::cout.flush(); + std::cerr.flush(); +#ifdef _WIN32 + ::TerminateProcess(::GetCurrentProcess(), static_cast(g_fail)); +#endif + return g_fail; +}