Thermal

1import depthai as dai
2import cv2
3
4THERMAL_IMAGE_BRIGHTNESS_STEP = 10
5
6with dai.Pipeline(True) as pipeline:
7    thermal = pipeline.create(dai.node.Thermal)
8    thermalImgOut = thermal.color.createOutputQueue()
9    thermalConfIn = thermal.inputConfig.createInputQueue()
10    thermalConf = dai.ThermalConfig()
11
12    pipeline.start()
13    WINDOW_NAME = "thermal"
14    cv2.namedWindow(WINDOW_NAME, cv2.WINDOW_NORMAL)
15    initialRescaleDone = False
16    while True:
17        thermalImg = thermalImgOut.get()
18        if not initialRescaleDone:
19            cv2.resizeWindow(WINDOW_NAME, thermalImg.getWidth(), thermalImg.getHeight())
20            initialRescaleDone = True
21        cv2.imshow(WINDOW_NAME, thermalImg.getCvFrame())
22        key = cv2.waitKey(1)
23        changed = False
24        if key == ord("q"):
25            break
26        elif key == ord("n"):
27            if thermalConf.imageParams.brightnessLevel is None:
28                thermalConf.imageParams.brightnessLevel = THERMAL_IMAGE_BRIGHTNESS_STEP
29            if (
30                thermalConf.imageParams.brightnessLevel - THERMAL_IMAGE_BRIGHTNESS_STEP
31            ) <= THERMAL_IMAGE_BRIGHTNESS_STEP:
32                thermalConf.imageParams.brightnessLevel = THERMAL_IMAGE_BRIGHTNESS_STEP
33            thermalConf.imageParams.brightnessLevel -= THERMAL_IMAGE_BRIGHTNESS_STEP
34            print(
35                "Set image brightness level to ",
36                thermalConf.imageParams.brightnessLevel,
37            )
38            changed = True
39        elif key == ord("m"):
40            if thermalConf.imageParams.brightnessLevel is None:
41                thermalConf.imageParams.brightnessLevel = 0
42            if (
43                thermalConf.imageParams.brightnessLevel + THERMAL_IMAGE_BRIGHTNESS_STEP
44            ) >= 255:
45                thermalConf.imageParams.brightnessLevel = (
46                    255 - THERMAL_IMAGE_BRIGHTNESS_STEP
47                )
48            thermalConf.imageParams.brightnessLevel += THERMAL_IMAGE_BRIGHTNESS_STEP
49            print(
50                "Set image brightness level to ",
51                thermalConf.imageParams.brightnessLevel,
52            )
53            changed = True
54        elif key == ord("a"):
55            if thermalConf.ffcParams.autoFFC is None:
56                thermalConf.ffcParams.autoFFC = True
57            thermalConf.ffcParams.autoFFC = not thermalConf.ffcParams.autoFFC
58            print(
59                "Set auto shutter to",
60                "on." if thermalConf.ffcParams.autoFFC else "off.",
61            )
62            changed = True
63        elif key == ord("s"):
64            if thermalConf.ffcParams.closeManualShutter is None:
65                thermalConf.ffcParams.closeManualShutter = False
66            thermalConf.ffcParams.closeManualShutter = (
67                not thermalConf.ffcParams.closeManualShutter
68            )
69            print(
70                "Closing" if thermalConf.ffcParams.closeManualShutter else "Opening",
71                "manual shutter.",
72            )
73            changed = True
74
75        if changed:
76            thermalConfIn.send(thermalConf)

1/*
2    Thermal camera example.
3    Streams the temperature image from a thermal sensor and
4    displays it with a crosshair with the temperature value at that point.
5*/
6#include <iostream>
7#include <opencv2/opencv.hpp>
8
9#include "depthai/depthai.hpp"
10#include "depthai/pipeline/InputQueue.hpp"
11#include "depthai/pipeline/datatype/ThermalConfig.hpp"
12
13volatile int mouseX, mouseY = 0;
14void mouseCallback(int event, int x, int y, int flags, void* userdata) {
15    mouseX = x;
16    mouseY = y;
17}
18
19const cv::Scalar WHITE(255, 255, 255);
20
21constexpr int THERMAL_IMAGE_BRIGHTNESS_STEP = 10;
22
23int main(int argc, char** args) {
24    dai::Pipeline pipeline(true);
25    auto thermal = pipeline.create<dai::node::Thermal>();
26    auto outTemp = thermal->temperature.createOutputQueue();
27    auto inConfig = thermal->inputConfig.createInputQueue();
28    auto thermalConfig = std::make_shared<dai::ThermalConfig>();
29    pipeline.start();
30
31    const char* TEMP_WINDOW = "Thermal";
32    cv::namedWindow(TEMP_WINDOW, cv::WINDOW_NORMAL);
33    cv::setMouseCallback(TEMP_WINDOW, mouseCallback);
34    const int WINDOW_SCALE_MULTIPLIER = 4;
35    bool initialWindowResizeDone = false;
36    while(true) {
37        auto tempImgFrame = outTemp->get<dai::ImgFrame>();
38        // On OAK-T the thermal stream is rather tiny, so we scale it up for better visualization.
39        if(!initialWindowResizeDone) {
40            cv::resizeWindow(TEMP_WINDOW, tempImgFrame->getWidth() * WINDOW_SCALE_MULTIPLIER, tempImgFrame->getHeight() * WINDOW_SCALE_MULTIPLIER);
41            initialWindowResizeDone = true;
42        }
43        // Convert the FP16 image frame to CV_32F.
44        cv::Mat frameFp32(tempImgFrame->getHeight(), tempImgFrame->getWidth(), CV_32F);
45        tempImgFrame->getCvFrame().convertTo(frameFp32, CV_32F);
46        // Colorize the temperature frame.
47        cv::Mat normalized;
48        cv::normalize(frameFp32, normalized, 0, 255, cv::NORM_MINMAX, CV_8UC1);
49        cv::Mat colormapped(tempImgFrame->getHeight(), tempImgFrame->getWidth(), CV_8UC3);
50        cv::applyColorMap(normalized, colormapped, cv::COLORMAP_MAGMA);
51        if(mouseX < 0 || mouseY < 0 || mouseX >= colormapped.cols || mouseY >= colormapped.rows) {
52            mouseX = std::max(0, std::min(static_cast<int>(mouseX), colormapped.cols - 1));
53            mouseY = std::max(0, std::min(static_cast<int>(mouseY), colormapped.rows - 1));
54        }
55        double min, max;
56        cv::minMaxLoc(frameFp32, &min, &max);
57        const cv::Scalar textColor(255, 255, 255);
58        ;
59        // Draw crosshair
60        cv::line(colormapped, cv::Point(mouseX - 10, mouseY), cv::Point(mouseX + 10, mouseY), textColor, 1);
61        cv::line(colormapped, cv::Point(mouseX, mouseY - 10), cv::Point(mouseX, mouseY + 10), textColor, 1);
62        // Draw deg C
63        char text[32];
64        snprintf(text, sizeof(text), "%.1f deg C", frameFp32.at<float>(mouseY, mouseX));
65        bool putTextLeft = mouseX > colormapped.cols / 2;
66        cv::putText(colormapped, text, cv::Point(putTextLeft ? mouseX - 100 : mouseX + 10, mouseY - 10), cv::FONT_HERSHEY_SIMPLEX, 0.5, textColor, 1);
67        cv::imshow(TEMP_WINDOW, colormapped);
68        // Can add controls for the sensor in the future here.
69        int key = cv::waitKey(1);
70        bool confUpdated = false;
71        if(key == 'q') {
72            break;
73        } else if(key == 'a') {
74            if(!thermalConfig->ffcParams.autoFFC) {
75                thermalConfig->ffcParams.autoFFC = false;
76            }
77            thermalConfig->ffcParams.autoFFC = !*thermalConfig->ffcParams.autoFFC;
78            confUpdated = true;
79        } else if(key == 'n') {
80            if(!thermalConfig->imageParams.brightnessLevel) {
81                thermalConfig->imageParams.brightnessLevel = 1;
82            }
83            if(*thermalConfig->imageParams.brightnessLevel >= 1) {
84                *thermalConfig->imageParams.brightnessLevel -= 1;
85            } else {
86                thermalConfig->imageParams.brightnessLevel = 0;
87            }
88            confUpdated = true;
89        } else if(key == 'm') {
90            if(!thermalConfig->imageParams.brightnessLevel) {
91                thermalConfig->imageParams.brightnessLevel = 0;
92            }
93            if(thermalConfig->imageParams.brightnessLevel >= 3) {
94                thermalConfig->imageParams.brightnessLevel = 3;
95            }
96            *thermalConfig->imageParams.brightnessLevel += 1;
97            confUpdated = true;
98        } else if(key == 'r') {
99            if(!thermalConfig->imageParams.orientation) {
100                thermalConfig->imageParams.orientation = dai::ThermalConfig::ThermalImageOrientation::Normal;
101            }
102            auto orientation = static_cast<uint8_t>(*thermalConfig->imageParams.orientation) + 1;
103            if(orientation > 3) {
104                orientation = 0;
105            }
106            thermalConfig->imageParams.orientation = static_cast<dai::ThermalConfig::ThermalImageOrientation>(orientation);
107            confUpdated = true;
108        } else if(key == 't') {
109            if(!thermalConfig->imageParams.timeNoiseFilterLevel) {
110                thermalConfig->imageParams.timeNoiseFilterLevel = 1;
111            }
112            if(*thermalConfig->imageParams.timeNoiseFilterLevel == 0) {
113                thermalConfig->imageParams.timeNoiseFilterLevel = 0;
114            } else {
115                *thermalConfig->imageParams.timeNoiseFilterLevel -= 1;
116            }
117            confUpdated = true;
118        } else if(key == 'z') {
119            if(!thermalConfig->imageParams.timeNoiseFilterLevel) {
120                thermalConfig->imageParams.timeNoiseFilterLevel = 0;
121            }
122            if(*thermalConfig->imageParams.timeNoiseFilterLevel == 3) {
123                thermalConfig->imageParams.timeNoiseFilterLevel = 3;
124            } else {
125                *thermalConfig->imageParams.timeNoiseFilterLevel += 1;
126            }
127            confUpdated = true;
128        } else if(key == 's') {
129            if(!thermalConfig->ffcParams.closeManualShutter.has_value()) {
130                thermalConfig->ffcParams.closeManualShutter = false;
131            }
132            *thermalConfig->ffcParams.closeManualShutter = !*thermalConfig->ffcParams.closeManualShutter;
133            std::cout << (*thermalConfig->ffcParams.closeManualShutter ? "Closing" : "Opening") << " manual shutter." << std::endl;
134            confUpdated = true;
135        }
136        if(confUpdated) {
137            inConfig->send(thermalConfig);
138        }
139    }
140
141    return 0;
142}