【ハンズオン資料】GR-LYCHEEとOpenCVで画像認識やってみよう

      
      /* GR-LYCHEE Sketch Template V1.04 */
      #include <Arduino.h>

      #define INTERVAL 50

      void setup()
      {
        Serial.begin(9600);
        pinMode(LED_RED,    OUTPUT);
        pinMode(LED_ORANGE, OUTPUT);
        pinMode(LED_YELLOW, OUTPUT);
        pinMode(LED_GREEN,  OUTPUT);
        pinMode(USER_BUTTON0, INPUT);
      }

      void loop()
      {
          while(digitalRead(USER_BUTTON0) == 0){
              digitalWrite(LED_GREEN, 1);
              delay(INTERVAL);
              digitalWrite(LED_GREEN, 0);
              delay(INTERVAL);
            Serial.println("I'm LYCHEE!");
          }
          digitalWrite(LED_RED, 1);
          delay(INTERVAL);
          digitalWrite(LED_RED, 0);
          digitalWrite(LED_ORANGE, 1);
          delay(INTERVAL);
          digitalWrite(LED_ORANGE, 0);
          digitalWrite(LED_YELLOW, 1);
          delay(INTERVAL);
          digitalWrite(LED_YELLOW, 0);
      }
      
      

      
      // Sample for GR-PEACH, GR-LYCHEE
      // Required hardware: Camera, USB
      // Public Domain

      #include <Arduino.h>
      #include <Camera.h>
      #include "DisplayApp.h"

      #define LOOP_WAITTIME 17 // 17ms for 60 fps of camera spec.
      Camera camera(640, 480);
      static DisplayApp display_app;

      void setup() {
        Serial.begin(9600);
        Serial.println("start");

        camera.begin();
      }

      void loop() {
        static unsigned long last_time = millis();
        while ((millis() - last_time) < LOOP_WAITTIME);
        last_time = millis();

        display_app.SendJpeg(camera.getJpegAdr(), (int)camera.createJpeg());
        delay(1);
      }
      
      

      
      # Copyright 2015 The TensorFlow Authors. All Rights Reserved.
      #
      # Licensed under the Apache License, Version 2.0 (the "License");
      # you may not use this file except in compliance with the License.
      # You may obtain a copy of the License at
      #
      #     http://www.apache.org/licenses/LICENSE-2.0
      #
      # Unless required by applicable law or agreed to in writing, software
      # distributed under the License is distributed on an "AS IS" BASIS,
      # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      # See the License for the specific language governing permissions and
      # limitations under the License.
      # ==============================================================================

      """A very simple MNIST classifier.

      See extensive documentation at
      https://www.tensorflow.org/get_started/mnist/beginners
      """
      from __future__ import absolute_import
      from __future__ import division
      from __future__ import print_function

      import argparse
      import sys

      from tensorflow.examples.tutorials.mnist import input_data

      import tensorflow as tf

      FLAGS = None


      def main(_):
        # Import data
        mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)

        # Create the model
        x = tf.placeholder(tf.float32, [None, 784])

        #Add Renesas 2 --------- ----------
        # change
        #  x_ = tf.placeholder(tf.float32, [None, 784])
        #  x = tf.reshape(x_, [-1])
        # --------- ----------

        W = tf.Variable(tf.zeros([784, 10]))
        b = tf.Variable(tf.zeros([10]))
        y = tf.matmul(x, W) + b

        # Define loss and optimizer
        y_ = tf.placeholder(tf.float32, [None, 10])

        # The raw formulation of cross-entropy,
        #
        #   tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(tf.nn.softmax(y)),
        #                                 reduction_indices=[1]))
        #
        # can be numerically unstable.
        #
        # So here we use tf.nn.softmax_cross_entropy_with_logits on the raw
        # outputs of 'y', and then average across the batch.
        cross_entropy = tf.reduce_mean(
            tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))
        train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

        sess = tf.InteractiveSession()
        tf.global_variables_initializer().run()
        # Train
        for _ in range(1000):
          batch_xs, batch_ys = mnist.train.next_batch(100)
          sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

        # Test trained model
        correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
        print(sess.run(accuracy, feed_dict={x: mnist.test.images,
                                            y_: mnist.test.labels}))

        #Add Renesas 1 --------- ----------
        import os
        #Save Learned AI
        out_dir = "./tf_LearnedModel"
        if os.path.isdir(out_dir) is False:
            os.makedirs(out_dir)
        saver = tf.train.Saver()
        saver.save(sess, out_dir+"/tf_LearnedModel")
        # --------- ----------

      if __name__ == '__main__':
        parser = argparse.ArgumentParser()
        parser.add_argument('--data_dir', type=str, default='/tmp/tensorflow/mnist/input_data',
                            help='Directory for storing input data')
        FLAGS, unparsed = parser.parse_known_args()
        tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)
      

      
      #include <Arduino.h>
      #include <Camera.h>
      #include <opencv.hpp>
      #include <DisplayApp.h>

      #ifdef __cplusplus
      extern "C" {
      #endif
      #include "eAI_translated/Typedef.h"
      #include "eAI_translated/input_image_0.h"
      #include "eAI_translated/layer_graph.h"
      TPrecision* dnn_compute(TPrecision* input_img);
      #ifdef __cplusplus
      }
      #endif

      // To monitor realtime on PC, you need DisplayApp on following site.
      // Connect USB0(not for mbed interface) to your PC
      // os.mbed.com/.../

      using namespace cv;

      #define IMAGE_HW 320
      #define IMAGE_VW 240
      #define INPUT_HEIGHT 28
      #define INPUT_WIDTH 28

      Camera camera(IMAGE_HW, IMAGE_VW);
      DisplayApp display_app;
      void paste(cv::Mat dst, cv::Mat src, int x, int y, int width, int height) {
       cv::Mat resized_img;
       cv::resize(src, resized_img, cv::Size(width, height));

       if (x >= dst.cols || y >= dst.rows) return;
       int w = (x >= 0) ? std::min(dst.cols - x, resized_img.cols) : std::min(std::max(resized_img.cols + x, 0), dst.cols);
       int h = (y >= 0) ? std::min(dst.rows - y, resized_img.rows) : std::min(std::max(resized_img.rows + y, 0), dst.rows);
       int u = (x >= 0) ? 0 : std::min(-x, resized_img.cols - 1);
       int v = (y >= 0) ? 0 : std::min(-y, resized_img.rows - 1);
       int px = std::max(x, 0);
       int py = std::max(y, 0);

       cv::Mat roi_dst = dst(cv::Rect(px, py, w, h));
       cv::Mat roi_resized = resized_img(cv::Rect(u, v, w, h));
       roi_resized.copyTo(roi_dst);
      }

      int max_array(TPrecision* array, int length){
       int i;
       float max = array[0];
       int index = 0;

       for(i = 0; i < length; i++){
       if(array[i] > max){
       max = array[i];
       index = i;
       }
       }
       return index;
      }

      void setup() {
       Serial.begin(9600);
       camera.begin();
      }

      void loop() {
       Scalar red(0, 0, 255), green(0, 255, 0), blue(255, 0, 0);
       Scalar yellow = red + green;
       Scalar white = Scalar::all(255);
       Scalar black = Scalar::all(0);
       Scalar pink = Scalar(154, 51, 255);

       Mat img_raw(IMAGE_VW, IMAGE_HW, CV_8UC2, camera.getImageAdr());

       Mat pic, gray;
       cvtColor(img_raw, pic, COLOR_YUV2BGR_YUYV); //covert YUV to RGB
       cvtColor(img_raw, gray, COLOR_YUV2GRAY_YUYV); //covert from YUV to GRAY

       Mat roi(gray, Rect(80, 0, 240, 240));
       threshold(roi, roi, 90, 255, THRESH_BINARY);
       resize(roi, roi, Size(INPUT_WIDTH, INPUT_HEIGHT));
       for(int i = 0; i < 784; i++){
       data_in[i] = 1 - (float)roi.data[i] / 255;
       }

       TPrecision *prediction;
       TPrecision *input_img;
       TsInt i;

       input_img = data_in;
       prediction = (TPrecision*) (intptr_t) dnn_compute( input_img);

       // Drawing
       rectangle(pic, Rect(0, 0, 80, 240), white, FILLED);
       rectangle(pic, Rect(80, 0, 240, 240), red, 2);

       Mat roi2;
       cvtColor(roi, roi2, COLOR_GRAY2BGR);
       paste(pic, roi2, 5, 5, roi2.rows, roi2.cols);
       rectangle(pic, Rect(4, 4, 30, 30), red, 1);

       int max_index = max_array(prediction, 10);
       for(i = 0;i < 10;i++){
       Serial.print(i); Serial.print(":");
       Serial.println(prediction[i]);
       stringstream ss;
       ss << i;
       if(max_index == i){
       putText(pic, ss.str(), Point(0, 20 * i + 50), FONT_HERSHEY_SCRIPT_SIMPLEX, 0.5, pink, 1);
       rectangle(pic, Rect(20, 20 * i + 40, prediction[i] * 80, 10), pink, FILLED);
       } else {
       putText(pic, ss.str(), Point(0, 20 * i + 50), FONT_HERSHEY_SCRIPT_SIMPLEX, 0.5, black, 1);
       rectangle(pic, Rect(20, 20 * i + 40, prediction[i] * 80, 10), blue, FILLED);
       }
       }

       size_t jpegSize = camera.createJpeg(320, 240, pic.data,
       Camera::FORMAT_RGB888);
       display_app.SendJpeg(camera.getJpegAdr(), jpegSize);
       delay(10);

      }