mirror of
https://github.com/jomjol/AI-on-the-edge-device.git
synced 2026-01-27 12:50:39 +03:00
451 lines
14 KiB
C++
451 lines
14 KiB
C++
#include "defines.h"
|
|
|
|
#include "ClassFlowAlignment.h"
|
|
#include "ClassControllCamera.h"
|
|
#include "ClassFlowTakeImage.h"
|
|
#include "ClassFlow.h"
|
|
#include "MainFlowControl.h"
|
|
|
|
#include "CRotateImage.h"
|
|
#include "esp_log.h"
|
|
|
|
#include "ClassLogFile.h"
|
|
#include "psram.h"
|
|
|
|
static const char *TAG = "ALIGN";
|
|
|
|
void ClassFlowAlignment::SetInitialParameter(void)
|
|
{
|
|
anz_ref = 0;
|
|
Camera.ImageInitialRotate = 0;
|
|
Camera.ImageAntialiasing = false;
|
|
Camera.ImageInitialFlip = false;
|
|
namerawimage = "/sdcard/img_tmp/raw.jpg";
|
|
FileStoreRefAlignment = "/sdcard/config/align.txt";
|
|
ListFlowControll = NULL;
|
|
AlignAndCutImage = NULL;
|
|
ImageBasis = NULL;
|
|
ImageTMP = NULL;
|
|
#ifdef ALGROI_LOAD_FROM_MEM_AS_JPG
|
|
AlgROI = (ImageData *)malloc_psram_heap(std::string(TAG) + "->AlgROI", sizeof(ImageData), MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM);
|
|
#endif
|
|
previousElement = NULL;
|
|
disabled = false;
|
|
SAD_criteria = 0.05;
|
|
}
|
|
|
|
ClassFlowAlignment::ClassFlowAlignment(std::vector<ClassFlow *> *lfc)
|
|
{
|
|
SetInitialParameter();
|
|
ListFlowControll = lfc;
|
|
|
|
for (int i = 0; i < ListFlowControll->size(); ++i)
|
|
{
|
|
if (((*ListFlowControll)[i])->name().compare("ClassFlowTakeImage") == 0)
|
|
{
|
|
ImageBasis = ((ClassFlowTakeImage *)(*ListFlowControll)[i])->rawImage;
|
|
}
|
|
}
|
|
|
|
// the function take pictures does not exist --> must be created first ONLY FOR TEST PURPOSES
|
|
if (!ImageBasis)
|
|
{
|
|
ESP_LOGD(TAG, "CImageBasis had to be created");
|
|
ImageBasis = new CImageBasis("ImageBasis", namerawimage);
|
|
}
|
|
}
|
|
|
|
bool ClassFlowAlignment::ReadParameter(FILE *pfile, std::string &aktparamgraph)
|
|
{
|
|
aktparamgraph = trim_string_left_right(aktparamgraph);
|
|
if (aktparamgraph.size() == 0)
|
|
{
|
|
if (!GetNextParagraph(pfile, aktparamgraph))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if ((to_upper(aktparamgraph).compare("[ALIGNMENT]") != 0) && (to_upper(aktparamgraph).compare(";[ALIGNMENT]") != 0))
|
|
{
|
|
// Paragraph does not fit Alignment
|
|
return false;
|
|
}
|
|
|
|
int suchex = 20;
|
|
int suchey = 20;
|
|
int maxangle = 45;
|
|
int alg_algo = 0; // default=0; 1 =HIGHACCURACY; 2= FAST; 3= OFF //add disable aligment algo |01.2023
|
|
|
|
std::vector<std::string> splitted;
|
|
|
|
while (getNextLine(pfile, &aktparamgraph) && !isNewParagraph(aktparamgraph))
|
|
{
|
|
splitted = split_line(aktparamgraph);
|
|
|
|
if (splitted.size() > 1)
|
|
{
|
|
std::string _param = to_upper(splitted[0]);
|
|
|
|
if (_param == "FLIPIMAGESIZE")
|
|
{
|
|
Camera.ImageInitialFlip = alphanumeric_to_boolean(splitted[1]);
|
|
}
|
|
else if (_param == "INITIALROTATE")
|
|
{
|
|
if (is_string_numeric(splitted[1]))
|
|
{
|
|
Camera.ImageInitialRotate = std::stod(splitted[1]);
|
|
}
|
|
}
|
|
else if (_param == "SEARCHFIELDX")
|
|
{
|
|
if (is_string_numeric(splitted[1]))
|
|
{
|
|
suchex = clip_int(std::stoi(splitted[1]), 320, 0);
|
|
}
|
|
}
|
|
else if (_param == "SEARCHFIELDY")
|
|
{
|
|
if (is_string_numeric(splitted[1]))
|
|
{
|
|
suchey = clip_int(std::stoi(splitted[1]), 240, 0);
|
|
}
|
|
}
|
|
else if (_param == "SEARCHMAXANGLE")
|
|
{
|
|
if (is_string_numeric(splitted[1]))
|
|
{
|
|
maxangle = clip_int(std::stoi(splitted[1]), 180, 0);
|
|
}
|
|
}
|
|
else if (_param == "ANTIALIASING")
|
|
{
|
|
Camera.ImageAntialiasing = alphanumeric_to_boolean(splitted[1]);
|
|
}
|
|
else if (_param == "ALIGNMENTALGO")
|
|
{
|
|
if (to_upper(splitted[1]) == "HIGHACCURACY")
|
|
{
|
|
alg_algo = 1;
|
|
}
|
|
else if (to_upper(splitted[1]) == "FAST")
|
|
{
|
|
alg_algo = 2;
|
|
}
|
|
else if (to_upper(splitted[1]) == "OFF")
|
|
{
|
|
// no align algo if set to 3 = off => no draw ref //add disable aligment algo |01.2023
|
|
alg_algo = 3;
|
|
}
|
|
}
|
|
else if ((splitted.size() == 3) && (anz_ref < 2))
|
|
{
|
|
if (is_string_numeric(splitted[1]) && is_string_numeric(splitted[2]))
|
|
{
|
|
References[anz_ref].image_file = format_filename("/sdcard" + splitted[0]);
|
|
References[anz_ref].target_x = std::stod(splitted[1]);
|
|
References[anz_ref].target_y = std::stod(splitted[2]);
|
|
anz_ref++;
|
|
}
|
|
else
|
|
{
|
|
References[anz_ref].image_file = format_filename("/sdcard" + splitted[0]);
|
|
References[anz_ref].target_x = 10;
|
|
References[anz_ref].target_y = 10;
|
|
anz_ref++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < anz_ref; ++i)
|
|
{
|
|
References[i].search_x = suchex;
|
|
References[i].search_y = suchey;
|
|
References[i].search_max_angle = (float)maxangle;
|
|
References[i].fastalg_SAD_criteria = SAD_criteria;
|
|
References[i].alignment_algo = alg_algo;
|
|
}
|
|
|
|
// no align algo if set to 3 = off => no draw ref //add disable aligment algo |01.2023
|
|
if (References[0].alignment_algo != 3)
|
|
{
|
|
return LoadReferenceAlignmentValues();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
std::string ClassFlowAlignment::getHTMLSingleStep(std::string host)
|
|
{
|
|
std::string result;
|
|
|
|
result = "<p>Rotated Image: </p> <p><img src=\"" + host + "/img_tmp/rot.jpg\"></p>\n";
|
|
result = result + "<p>Found Alignment: </p> <p><img src=\"" + host + "/img_tmp/rot_roi.jpg\"></p>\n";
|
|
result = result + "<p>Aligned Image: </p> <p><img src=\"" + host + "/img_tmp/alg.jpg\"></p>\n";
|
|
return result;
|
|
}
|
|
|
|
bool ClassFlowAlignment::doFlow(std::string time)
|
|
{
|
|
#ifdef ALGROI_LOAD_FROM_MEM_AS_JPG
|
|
// AlgROI needs to be allocated before ImageTMP to avoid heap fragmentation
|
|
if (!AlgROI)
|
|
{
|
|
AlgROI = (ImageData *)heap_caps_realloc(AlgROI, sizeof(ImageData), MALLOC_CAP_8BIT | MALLOC_CAP_SPIRAM);
|
|
|
|
if (!AlgROI)
|
|
{
|
|
LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't allocate AlgROI");
|
|
LogFile.WriteHeapInfo("ClassFlowAlignment-doFlow");
|
|
}
|
|
}
|
|
|
|
if (AlgROI)
|
|
{
|
|
ImageBasis->writeToMemoryAsJPG((ImageData *)AlgROI, 90);
|
|
}
|
|
#endif
|
|
|
|
if (!ImageTMP)
|
|
{
|
|
ImageTMP = new CImageBasis("TempImage", ImageBasis); // Make sure the name does not get change, it is relevant for the PSRAM allocation!
|
|
|
|
if (!ImageTMP)
|
|
{
|
|
LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't allocate TempImage -> Exec this round aborted!");
|
|
LogFile.WriteHeapInfo("ClassFlowAlignment-doFlow");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
delete AlignAndCutImage;
|
|
AlignAndCutImage = new CAlignAndCutImage("AlignAndCutImage", ImageBasis, ImageTMP);
|
|
|
|
if (!AlignAndCutImage)
|
|
{
|
|
LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Can't allocate AlignAndCutImage -> Exec this round aborted!");
|
|
LogFile.WriteHeapInfo("ClassFlowAlignment-doFlow");
|
|
return false;
|
|
}
|
|
|
|
CRotateImage rt("rawImage", AlignAndCutImage, ImageTMP, Camera.ImageInitialFlip);
|
|
|
|
if (Camera.ImageInitialFlip)
|
|
{
|
|
int temp_value = ImageBasis->height;
|
|
ImageBasis->height = ImageBasis->width;
|
|
ImageBasis->width = temp_value;
|
|
|
|
temp_value = ImageTMP->width;
|
|
ImageTMP->width = ImageTMP->height;
|
|
ImageTMP->height = temp_value;
|
|
}
|
|
|
|
if (((Camera.ImageInitialRotate > 0) && (Camera.ImageInitialRotate < 360)) || Camera.ImageInitialFlip)
|
|
{
|
|
if (Camera.ImageAntialiasing)
|
|
{
|
|
rt.RotateAntiAliasing(Camera.ImageInitialRotate);
|
|
}
|
|
else
|
|
{
|
|
rt.Rotate(Camera.ImageInitialRotate);
|
|
}
|
|
|
|
if (Camera.SaveAllFiles)
|
|
{
|
|
AlignAndCutImage->SaveToFile(format_filename("/sdcard/img_tmp/rot.jpg"));
|
|
}
|
|
}
|
|
|
|
// no align algo if set to 3 = off //add disable aligment algo |01.2023
|
|
if (References[0].alignment_algo != 3)
|
|
{
|
|
int res = AlignAndCutImage->Align(&References[0], &References[1]);
|
|
if (res >= Alignment_OK)
|
|
{
|
|
LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Alignment OK");
|
|
if (res == Fast_Alignment_OK)
|
|
{
|
|
SaveReferenceAlignmentValues();
|
|
}
|
|
flowctrl.AlignmentOk = true;
|
|
}
|
|
else
|
|
{
|
|
// Alignment failed
|
|
LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Alignment failed");
|
|
flowctrl.AlignmentOk = false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
flowctrl.AlignmentOk = true;
|
|
}
|
|
|
|
#ifdef ALGROI_LOAD_FROM_MEM_AS_JPG
|
|
if (AlgROI)
|
|
{
|
|
// no align algo if set to 3 = off => no draw ref //add disable aligment algo |01.2023
|
|
if (References[0].alignment_algo != 3)
|
|
{
|
|
DrawRef(ImageTMP);
|
|
}
|
|
|
|
flowctrl.DigitDrawROI(ImageTMP);
|
|
flowctrl.AnalogDrawROI(ImageTMP);
|
|
ImageTMP->writeToMemoryAsJPG((ImageData *)AlgROI, 90);
|
|
}
|
|
#endif
|
|
|
|
if (Camera.SaveAllFiles)
|
|
{
|
|
AlignAndCutImage->SaveToFile(format_filename("/sdcard/img_tmp/alg.jpg"));
|
|
ImageTMP->SaveToFile(format_filename("/sdcard/img_tmp/alg_roi.jpg"));
|
|
}
|
|
|
|
// must be deleted to have memory space for loading tflite
|
|
delete ImageTMP;
|
|
ImageTMP = NULL;
|
|
|
|
return true;
|
|
}
|
|
|
|
void ClassFlowAlignment::SaveReferenceAlignmentValues(void)
|
|
{
|
|
FILE *pFile = fopen(FileStoreRefAlignment.c_str(), "w");
|
|
|
|
std::string temp_time;
|
|
if (strlen(temp_time.c_str()) == 0)
|
|
{
|
|
time_t rawtime;
|
|
struct tm *timeinfo;
|
|
char buffer[80];
|
|
|
|
time(&rawtime);
|
|
timeinfo = localtime(&rawtime);
|
|
|
|
strftime(buffer, 80, "%Y-%m-%dT%H:%M:%S", timeinfo);
|
|
temp_time = std::string(buffer);
|
|
}
|
|
|
|
fputs(temp_time.c_str(), pFile);
|
|
fputs("\n", pFile);
|
|
|
|
std::string temp_value = std::to_string(References[0].fastalg_x) + "\t" + std::to_string(References[0].fastalg_y);
|
|
temp_value = temp_value + "\t" + std::to_string(References[0].fastalg_SAD) + "\t" + std::to_string(References[0].fastalg_min);
|
|
temp_value = temp_value + "\t" + std::to_string(References[0].fastalg_max) + "\t" + std::to_string(References[0].fastalg_avg);
|
|
fputs(temp_value.c_str(), pFile);
|
|
fputs("\n", pFile);
|
|
|
|
temp_value = std::to_string(References[1].fastalg_x) + "\t" + std::to_string(References[1].fastalg_y);
|
|
temp_value = temp_value + "\t" + std::to_string(References[1].fastalg_SAD) + "\t" + std::to_string(References[1].fastalg_min);
|
|
temp_value = temp_value + "\t" + std::to_string(References[1].fastalg_max) + "\t" + std::to_string(References[1].fastalg_avg);
|
|
fputs(temp_value.c_str(), pFile);
|
|
fputs("\n", pFile);
|
|
|
|
fclose(pFile);
|
|
}
|
|
|
|
bool ClassFlowAlignment::LoadReferenceAlignmentValues(void)
|
|
{
|
|
FILE *pFile = fopen(FileStoreRefAlignment.c_str(), "r");
|
|
if (pFile == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
char temp_bufer[1024];
|
|
// erste Zeile: 2025-03-16T18:50:22
|
|
if (!fgets(temp_bufer, 1024, pFile))
|
|
{
|
|
fclose(pFile);
|
|
ESP_LOGE(TAG, "/sdcard/config/align.txt empty!");
|
|
return false;
|
|
}
|
|
|
|
// zweite Zeile: 177 342 -0.000000 6144 1611659784 0.000000
|
|
if (!fgets(temp_bufer, 1024, pFile))
|
|
{
|
|
fclose(pFile);
|
|
ESP_LOGE(TAG, "/sdcard/config/align.txt empty!");
|
|
return false;
|
|
}
|
|
|
|
std::vector<std::string> splitted;
|
|
splitted = split_line(temp_bufer, "\t");
|
|
|
|
if (splitted.size() < 6)
|
|
{
|
|
fclose(pFile);
|
|
ESP_LOGE(TAG, "/sdcard/config/align.txt wrong format!");
|
|
return false;
|
|
}
|
|
|
|
if (is_string_numeric(splitted[0]) && is_string_numeric(splitted[1]) && is_string_numeric(splitted[2]) &&
|
|
is_string_numeric(splitted[3]) && is_string_numeric(splitted[4]) && is_string_numeric(splitted[5]))
|
|
{
|
|
References[0].fastalg_x = stoi(splitted[0]);
|
|
References[0].fastalg_y = stoi(splitted[1]);
|
|
References[0].fastalg_SAD = stof(splitted[2]);
|
|
References[0].fastalg_min = stoi(splitted[3]);
|
|
References[0].fastalg_max = stoi(splitted[4]);
|
|
References[0].fastalg_avg = stof(splitted[5]);
|
|
}
|
|
else
|
|
{
|
|
fclose(pFile);
|
|
ESP_LOGE(TAG, "/sdcard/config/align.txt wrong format!");
|
|
return false;
|
|
}
|
|
|
|
// dritte Zeile: 398 145 -0.000000 6144 1611659784 0.000000
|
|
if (!fgets(temp_bufer, 1024, pFile))
|
|
{
|
|
fclose(pFile);
|
|
ESP_LOGE(TAG, "/sdcard/config/align.txt empty!");
|
|
return false;
|
|
}
|
|
|
|
splitted = split_line(temp_bufer, "\t");
|
|
|
|
if (splitted.size() < 6)
|
|
{
|
|
fclose(pFile);
|
|
ESP_LOGE(TAG, "/sdcard/config/align.txt wrong format!");
|
|
return false;
|
|
}
|
|
|
|
if (is_string_numeric(splitted[0]) && is_string_numeric(splitted[1]) && is_string_numeric(splitted[2]) &&
|
|
is_string_numeric(splitted[3]) && is_string_numeric(splitted[4]) && is_string_numeric(splitted[5]))
|
|
{
|
|
References[1].fastalg_x = stoi(splitted[0]);
|
|
References[1].fastalg_y = stoi(splitted[1]);
|
|
References[1].fastalg_SAD = stof(splitted[2]);
|
|
References[1].fastalg_min = stoi(splitted[3]);
|
|
References[1].fastalg_max = stoi(splitted[4]);
|
|
References[1].fastalg_avg = stof(splitted[5]);
|
|
}
|
|
else
|
|
{
|
|
fclose(pFile);
|
|
ESP_LOGE(TAG, "/sdcard/config/align.txt wrong format!");
|
|
return false;
|
|
}
|
|
|
|
fclose(pFile);
|
|
|
|
return true;
|
|
}
|
|
|
|
void ClassFlowAlignment::DrawRef(CImageBasis *Image)
|
|
{
|
|
if (Image->ImageOkay())
|
|
{
|
|
Image->drawRect(References[0].target_x, References[0].target_y, References[0].width, References[0].height, 255, 0, 0, 2);
|
|
Image->drawRect(References[1].target_x, References[1].target_y, References[1].width, References[1].height, 255, 0, 0, 2);
|
|
}
|
|
}
|