Merge branch 'master' of https://github.com/jomjol/AI-on-the-edge-device

README.md

@@ -19,7 +19,7 @@ A 3d-printable housing can be found here: https://www.thingiverse.com/thing:4571
 
 ### Known Issues
 
-* reboot on extensive web access due to the limits of the internal web server
+* Reboot on extensive web access due to the limits of the internal web server
 
 ------
 

code/lib/jomjol_tfliteclass/CTfLiteClass._cpp_old

@@ -0,0 +1,254 @@
+#include "CTfLiteClass.h"
+
+#include "bitmap_image.hpp"
+
+#include <sys/stat.h>
+
+float CTfLiteClass::GetOutputValue(int nr)
+{
+    TfLiteTensor* output2 = this->interpreter->output(0);
+
+    int numeroutput = output2->dims->data[1];
+    if ((nr+1) > numeroutput)
+      return -1000;
+
+    return output2->data.f[nr];
+}
+
+
+int CTfLiteClass::GetClassFromImage(std::string _fn)
+{
+//  printf("Before Load image %s\n", _fn.c_str());
+    if (!LoadInputImage(_fn))
+      return -1000;
+//  printf("After Load image %s\n", _fn.c_str());
+
+    Invoke();
+  printf("After Invoke %s\n", _fn.c_str());
+
+    return GetOutClassification();
+//    return 0;
+}
+
+int CTfLiteClass::GetOutClassification()
+{
+  TfLiteTensor* output2 = interpreter->output(0);
+
+  float zw_max = 0;
+  float zw;
+  int zw_class = -1;
+
+  if (output2 == NULL)
+    return -1;
+
+  int numeroutput = output2->dims->data[1];
+  for (int i = 0; i < numeroutput; ++i)
+  {
+    zw = output2->data.f[i];
+    if (zw > zw_max)
+    {
+        zw_max = zw;
+        zw_class = i;
+    }
+  }
+//  printf("Result Ziffer: %d\n", zw_class);       
+  return zw_class;
+}
+
+void CTfLiteClass::GetInputDimension(bool silent = false)
+{
+  TfLiteTensor* input2 = this->interpreter->input(0);
+
+  int numdim = input2->dims->size;
+  if (!silent)  printf("NumDimension: %d\n", numdim);  
+
+  int sizeofdim;
+  for (int j = 0; j < numdim; ++j)
+  {
+    sizeofdim = input2->dims->data[j];
+    if (!silent) printf("SizeOfDimension %d: %d\n", j, sizeofdim);  
+    if (j == 1) im_height = sizeofdim;
+    if (j == 2) im_width = sizeofdim;
+    if (j == 3) im_channel = sizeofdim;
+  }
+}
+
+
+void CTfLiteClass::GetOutPut()
+{
+  TfLiteTensor* output2 = this->interpreter->output(0);
+
+  int numdim = output2->dims->size;
+  printf("NumDimension: %d\n", numdim);  
+
+  int sizeofdim;
+  for (int j = 0; j < numdim; ++j)
+  {
+    sizeofdim = output2->dims->data[j];
+    printf("SizeOfDimension %d: %d\n", j, sizeofdim);  
+  }
+
+
+  float fo;
+
+  // Process the inference results.
+  int numeroutput = output2->dims->data[1];
+  for (int i = 0; i < numeroutput; ++i)
+  {
+   fo = output2->data.f[i];
+    printf("Result %d: %f\n", i, fo);  
+  }
+}
+
+void CTfLiteClass::Invoke()
+{
+    interpreter->Invoke();
+//    printf("Invoke Done.\n");
+}
+
+
+bool CTfLiteClass::LoadInputImage(std::string _fn)
+{
+    bitmap_image image(_fn);
+    unsigned int w = image.width();
+    unsigned int h = image.height();
+    unsigned char red, green, blue;
+
+    input_i = 0;
+    float* input_data_ptr = (interpreter->input(0))->data.f;
+
+    for (int y = 0; y < h; ++y)
+        for (int x = 0; x < w; ++x)
+            {
+                red = image.red_channel(x, y);
+                green = image.green_channel(x, y);
+                blue = image.blue_channel(x, y);
+                *(input_data_ptr) = (float) red;
+                input_data_ptr++;
+                *(input_data_ptr) = (float) green;
+                input_data_ptr++;
+                *(input_data_ptr) = (float) blue;
+                input_data_ptr++;
+
+//                printf("BMP: %f %f %f\n", (float) red, (float) green, (float) blue);
+
+            }
+    return true;
+}
+
+
+void CTfLiteClass::MakeAllocate()
+{
+/*    
+  this->micro_op_resolver.AddBuiltin(
+                                tflite::BuiltinOperator_RESHAPE,
+                                tflite::ops::micro::Register_RESHAPE());
+  this->micro_op_resolver.AddBuiltin(tflite::BuiltinOperator_CONV_2D,
+                               tflite::ops::micro::Register_CONV_2D());
+  this->micro_op_resolver.AddBuiltin(tflite::BuiltinOperator_FULLY_CONNECTED,
+                               tflite::ops::micro::Register_FULLY_CONNECTED());
+  this->micro_op_resolver.AddBuiltin(tflite::BuiltinOperator_SOFTMAX,
+                               tflite::ops::micro::Register_SOFTMAX());
+  this->micro_op_resolver.AddBuiltin(tflite::BuiltinOperator_DEPTHWISE_CONV_2D,
+                               tflite::ops::micro::Register_DEPTHWISE_CONV_2D());
+
+
+    this->interpreter = new tflite::MicroInterpreter(this->model, this->micro_op_resolver, this->tensor_arena, this->kTensorArenaSize, this->error_reporter);
+*/
+
+
+    static tflite::ops::micro::AllOpsResolver resolver;
+    this->interpreter = new tflite::MicroInterpreter(this->model, resolver, this->tensor_arena, this->kTensorArenaSize, this->error_reporter);
+
+    TfLiteStatus allocate_status = this->interpreter->AllocateTensors();
+    if (allocate_status != kTfLiteOk) {
+        TF_LITE_REPORT_ERROR(error_reporter, "AllocateTensors() failed");
+    this->GetInputDimension();   
+    return;
+  }
+
+    printf("Allocate Done.\n");
+}
+
+void CTfLiteClass::GetInputTensorSize(){
+    float *zw = this->input;
+    int test = sizeof(zw);
+    printf("Input Tensor Dimension: %d\n", test);       
+
+    printf("Input Tensor Dimension: %d\n", test);   
+}
+
+long CTfLiteClass::GetFileSize(std::string filename)
+{
+    struct stat stat_buf;
+    long rc = stat(filename.c_str(), &stat_buf);
+    return rc == 0 ? stat_buf.st_size : -1;
+}
+
+
+unsigned char* CTfLiteClass::ReadFileToCharArray(std::string _fn)
+{
+    long size;
+
+    size = this->GetFileSize(_fn);
+
+    if (size == -1)
+    {
+		printf("\nFile existiert nicht.\n");
+        return NULL;
+    }
+
+
+    unsigned char *result = (unsigned char*) malloc(size);
+
+	if(result != NULL) {
+//		printf("\nSpeicher ist reserviert\n");
+        FILE* f = fopen(_fn.c_str(), "rb");     // vorher  nur "r"
+        fread(result, 1, size, f);
+        fclose(f);        
+	}else {
+		printf("\nKein freier Speicher vorhanden.\n");
+	}    
+
+
+    return result;
+}
+
+void CTfLiteClass::LoadModel(std::string _fn){
+
+
+    this->error_reporter = new tflite::MicroErrorReporter;
+
+    unsigned char *rd;
+    rd = this->ReadFileToCharArray(_fn.c_str());
+//    printf("loadedfile: %d", (int) rd);
+
+    this->model = tflite::GetModel(rd);
+    free(rd);
+    TFLITE_MINIMAL_CHECK(model != nullptr); 
+    printf("tfile Loaded.\n");  
+
+}
+
+
+
+CTfLiteClass::CTfLiteClass()
+{
+//    this->accessSD = _accessSD;
+    this->model = nullptr;
+    this->interpreter = nullptr;
+    this->input = nullptr;
+    this->output = nullptr;  
+    this->kTensorArenaSize = 600 * 1024;
+    this->tensor_arena = new uint8_t[kTensorArenaSize];    
+
+//      micro_op_resolver.AddBuiltin(tflite::BuiltinOperator_CONV_2D,
+//                               tflite::ops::micro::Register_CONV_2D());
+}
+
+CTfLiteClass::~CTfLiteClass()
+{
+  delete this->tensor_arena;
+}        
+
+

code/lib/jomjol_tfliteclass/CTfLiteClass._h_old

@@ -0,0 +1,72 @@
+#pragma once
+
+#ifndef __CFINDTEMPLATE
+#define __CFINGTEMPLATE
+
+#define TFLITE_MINIMAL_CHECK(x)                              \
+  if (!(x)) {                                                \
+    fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); \
+    exit(1);                                                 \
+  }
+
+//#include "CAccessSD.h"
+#include "CFindTemplate.h"
+
+#include "tensorflow/lite/micro/kernels/all_ops_resolver.h"
+#include "tensorflow/lite/micro/micro_error_reporter.h"
+#include "tensorflow/lite/micro/micro_interpreter.h"
+#include "tensorflow/lite/schema/schema_generated.h"
+#include "tensorflow/lite/version.h"
+#include "tensorflow/lite/micro/kernels/micro_ops.h"
+#include "esp_err.h"
+#include "esp_log.h"
+
+//extern CAccessSDClass accessSD;
+
+class CTfLiteClass
+{
+    protected:
+//        CAccessSDClass *accessSD;
+
+        tflite::ErrorReporter* error_reporter;
+
+        const tflite::Model* model;
+        tflite::MicroInterpreter* interpreter;
+//        TfLiteTensor* input = nullptr;
+        TfLiteTensor* output = nullptr;     
+        static tflite::ops::micro::AllOpsResolver *resolver; 
+
+        tflite::MicroOpResolver<5> micro_op_resolver;
+
+
+        int kTensorArenaSize;
+        uint8_t *tensor_arena;
+
+        float* input;
+        int input_i;
+
+        int im_height, im_width, im_channel;
+
+        long GetFileSize(std::string filename);
+        unsigned char* ReadFileToCharArray(std::string _fn);
+
+    public:
+//        CTfLiteClass(CAccessSDClass *_accessSD);
+        CTfLiteClass();
+        ~CTfLiteClass();        
+        void LoadModel(std::string _fn);
+        void MakeAllocate();
+        void GetInputTensorSize();
+        bool LoadInputImage(std::string _fn);
+        void Invoke();
+        void GetOutPut();
+        int GetOutClassification();
+        int GetClassFromImage(std::string _fn);
+
+        float GetOutputValue(int nr);
+        void GetInputDimension(bool silent);
+
+};
+
+
+#endif

code/src/version.cpp

@@ -1,4 +1,4 @@
-const char* GIT_REV="4caca9b";
+const char* GIT_REV="de772d7";
 const char* GIT_TAG="";
-const char* GIT_BRANCH="master";
-const char* BUILD_TIME="2020-11-15 12:38";
+const char* GIT_BRANCH="rolling";
+const char* BUILD_TIME="2020-11-15 12:29";

code/src/version.h

@@ -13,7 +13,7 @@ extern "C"
 #include "Helper.h"
 #include <fstream>
 
-const char* GIT_BASE_BRANCH = "master - v4.0.0 - 2020-11-15";
+const char* GIT_BASE_BRANCH = "master - v3.1.0 - 2020-10-26";
 
 
 const char* git_base_branch(void)