Gestione dispositivi di Android

Visto che oramai e' chiaro che se si perde (o viene rubato il cellulare) ci si trova praticamente in mutande nei confronti di chi ritrova il telefono questa nuova funzione di Android di localizzare il telefono ed eventualmente rimuovere i dati e' fantastica

Di fatto e' necessario che il telefono abbia una scheda che permetta il traffico dati (se e' agganciato WiFi con le mie prove non funziona). Dopo di cio' ci si collega al link
https://www.google.com/android/devicemanager
e si puo' verificare (con ampio margine di errore) dove si trova il telefono, lo si puo' far squillare ed infine si possono cancellare da remoto i dati sensibili

Riconoscimento automatico oggetti in OpenCV

Una delle funzioni piu' carine di OpenCV e' quella che permette di individuare oggetti in automatico all'interno di una immagine. Il mio obbiettivo sarebbe quello di determinare la presenza di cartelli stradali.

Per una prova ho preso una normale immagine scattata con la fotocamera del cellulare

Ho cercato quindi di individuare in automatico la posizione del cartello di precedenza
Il programma deriva direttamente dagli esempi di OpenCV

-------------------------------------------------
#include <stdio.h>
#include <iostream>
#include "opencv2/core/core.hpp"
#include "opencv2/features2d/features2d.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/calib3d/calib3d.hpp"

using namespace cv;

void readme();

/** @function main */
int main( int argc, char** argv )
{
  if( argc != 3 )
  { readme(); return -1; }

  Mat img_object = imread( argv[1], CV_LOAD_IMAGE_GRAYSCALE );
  Mat img_scene = imread( argv[2], CV_LOAD_IMAGE_GRAYSCALE );

  if( !img_object.data || !img_scene.data )
  { std::cout<< " --(!) Error reading images " << std::endl; return -1; }

  //-- Step 1: Detect the keypoints using SURF Detector
  int minHessian = 400;

  SurfFeatureDetector detector( minHessian );

  std::vector<KeyPoint> keypoints_object, keypoints_scene;

  detector.detect( img_object, keypoints_object );
  detector.detect( img_scene, keypoints_scene );

  //-- Step 2: Calculate descriptors (feature vectors)
  SurfDescriptorExtractor extractor;

  Mat descriptors_object, descriptors_scene;

  extractor.compute( img_object, keypoints_object, descriptors_object );
  extractor.compute( img_scene, keypoints_scene, descriptors_scene );

  //-- Step 3: Matching descriptor vectors using FLANN matcher
  FlannBasedMatcher matcher;
  std::vector< DMatch > matches;
  matcher.match( descriptors_object, descriptors_scene, matches );

  double max_dist = 0; double min_dist = 100;

  //-- Quick calculation of max and min distances between keypoints
  for( int i = 0; i < descriptors_object.rows; i++ )
  { double dist = matches[i].distance;
    if( dist < min_dist ) min_dist = dist;
    if( dist > max_dist ) max_dist = dist;
  }

  printf("-- Max dist : %f \n", max_dist );
  printf("-- Min dist : %f \n", min_dist );

  //-- Draw only "good" matches (i.e. whose distance is less than 3*min_dist )
  std::vector< DMatch > good_matches;

  for( int i = 0; i < descriptors_object.rows; i++ )
  { if( matches[i].distance < 3*min_dist )
     { good_matches.push_back( matches[i]); }
  }

  Mat img_matches;
  drawMatches( img_object, keypoints_object, img_scene, keypoints_scene,
               good_matches, img_matches, Scalar::all(-1), Scalar::all(-1),
               vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );

  //-- Localize the object
  std::vector<Point2f> obj;
  std::vector<Point2f> scene;

  for( int i = 0; i < good_matches.size(); i++ )
  {
    //-- Get the keypoints from the good matches
    obj.push_back( keypoints_object[ good_matches[i].queryIdx ].pt );
    scene.push_back( keypoints_scene[ good_matches[i].trainIdx ].pt );
  }

  Mat H = findHomography( obj, scene, CV_RANSAC );

  //-- Get the corners from the image_1 ( the object to be "detected" )
  std::vector<Point2f> obj_corners(4);
  obj_corners[0] = cvPoint(0,0); obj_corners[1] = cvPoint( img_object.cols, 0 );
  obj_corners[2] = cvPoint( img_object.cols, img_object.rows ); obj_corners[3] = cvPoint( 0, img_object.rows );
  std::vector<Point2f> scene_corners(4);

  perspectiveTransform( obj_corners, scene_corners, H);

  //-- Draw lines between the corners (the mapped object in the scene - image_2 )
  line( img_matches, scene_corners[0] + Point2f( img_object.cols, 0), scene_corners[1] + Point2f( img_object.cols, 0), Scalar(0, 255, 0), 4 );
  line( img_matches, scene_corners[1] + Point2f( img_object.cols, 0), scene_corners[2] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 );
  line( img_matches, scene_corners[2] + Point2f( img_object.cols, 0), scene_corners[3] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 );
  line( img_matches, scene_corners[3] + Point2f( img_object.cols, 0), scene_corners[0] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 );

  //-- Show detected matches
  imshow( "Good Matches & Object detection", img_matches );

  waitKey(0);
  return 0;
  }

  /** @function readme */
  void readme()
  { std::cout << " Usage: ./SURF_descriptor <img1> <img2>" << std::endl; }
-------------------------------------------------

per prima cosa ho usato come immagine di training il cartello di precedenza estratto dalla medesima immagine.

Il risultato e' ottimale

a questo punto le cose si complicano. Ho scattato una seconda foto spostandomi di qualche metro per cambiare la prospettiva

Si ha ancora un qualche risultato ma chiaramente basta una piccola modifica per confondere l'algoritmo
Ancora piu' difficile. Invece di tagliare l'immagine ho preso una immagine generica di un cartello di precedenza (da Google Images)

il risultato e' decisamente pessimo

sostanzialmente un esperimento fallito e come al solito "conoscere la risposta aiuta nel risolvere un problema"

Motion Detection su Raspberry

Per valutare la potenza di calcolo di Raspberry per un eventuale sistema di controllo, ho ricompilato il programma presentato in questo post modificandolo leggermente (non volevo usare il monitor ma solo una connessione di rete via SSH per interagire con la Raspberry) eliminando il namedWindow

Per compilare il programma non ci sono problemi in quanto le libopencv-dev sono disponibili nei repository senza la necessita' di ricompilare da zero le OpenCV

Il sistema ha funzionato bene

anche se in alcuni casi vi sono artefatti

ecco il video completo

Fauna caldinese

Ribaltato giusto davanti al portone di casa, gentilmente accompagnato in un prato

Errore stray ‘\342’ in program

copiando un mio sorgente direttamente da questo blog e compilandolo su un'altra macchina e' comparso l'errore

 error: stray ‘\342’ in program

ovviamente non si tratta di un errore del programma dato che funziona su un'altra macchina
in realta' nella fase di copia incolla dal browser verso il text editor sono stati copiati dei codici UNICODE e non ASCII per cui, per esempio, quelle che io vedo come virgolette il calcolatore non le vede come tali e blocca la compilazione

Individuazione di volti con OpenCV

Sempre giocando con OpenCV e' divertente effettuare il riconoscimento automatico dei volti...una operazione di per se complessa si puo' svolgere sostanzialmente in realtime con poca potenza di calcolo

Prendendo l'esempio dei tutorial (con poche modifiche marginali) si puo' ottenere il risultato sottostante (e' stato modificato un parametro rispetto a quelli di default)

per il corretto funzionamento del programma si deve copiare il file haarcascade_frontalface_alt.xml nella directory del programma
---------------------------------------------------------
 #include "opencv2/objdetect/objdetect.hpp"
 #include "opencv2/highgui/highgui.hpp"
 #include "opencv2/imgproc/imgproc.hpp"

 #include <iostream>
 #include <stdio.h>

 using namespace std;
 using namespace cv;

 /** Function Headers */
 void detectAndDisplay( Mat frame );

 /** Global variables */
 String face_cascade_name = "haarcascade_frontalface_alt.xml";
 CascadeClassifier face_cascade;

 string window_name = "Capture - Face detection";
 RNG rng(12345);

 /** @function main */
 int main( int argc, const char** argv )
 {
   if( !face_cascade.load( face_cascade_name ) ){ printf("--(!)Error loading\n"); return -1; };
   Mat img = imread("immagine.jpg", CV_LOAD_IMAGE_UNCHANGED);
   detectAndDisplay(img); 
   waitKey(0); 
   return 0;
 }

void detectAndDisplay(Mat frame)
{
  std::vector<Rect> faces;
  Mat frame_gray;

  cvtColor( frame, frame_gray, CV_BGR2GRAY );
  equalizeHist( frame_gray, frame_gray );

  //-- Detect faces
  face_cascade.detectMultiScale( frame_gray, faces, 1.1, 2, 0|CV_HAAR_SCALE_IMAGE, Size(20, 20) );

  for( int i = 0; i < faces.size(); i++ )
  {
    Point center( faces[i].x + faces[i].width*0.5, faces[i].y + faces[i].height*0.5 );
    ellipse( frame, center, Size( faces[i].width*0.5, faces[i].height*0.5), 0, 0, 360, Scalar( 255, 0, 255 ), 4, 8, 0 );
    Mat faceROI = frame_gray( faces[i] );
  }
  imshow( window_name, frame );

  vector<int> compression_params; 
  compression_params.push_back(CV_IMWRITE_JPEG_QUALITY); 
  compression_params.push_back(98);
  bool bSuccess = imwrite("elaborata2.jpg", frame, compression_params); 

 }

Motion Detection in OpenCV

sempre per fare un po' di esperienza per rendere la Raspberry un sistema di controllo video, un esempio di motion detection con OpenCV ripreso da questo link e leggermente modificato per salvare il video su disco
(il video e' accelerato)

per adesso il programma e' stato testato su un portatile. Presto provero' se Raspberry e' in grado di gestire il flusso dati video ed il relativo calcolo in realtime

--------------------------------------------
#include<opencv2/opencv.hpp>
#include<iostream>
#include<vector>

using namespace std;

int main(int argc, char *argv[])
{
    cv::Mat frame;
    cv::Mat back;
    cv::Mat fore;
    cv::VideoCapture cap(0);
    cv::BackgroundSubtractorMOG2 bg;
    bg.nmixtures = 3;
    bg.bShadowDetection = false;

    std::vector<std::vector<cv::Point> > contours;

    cv::namedWindow("Frame");


   double dWidth = cap.get(CV_CAP_PROP_FRAME_WIDTH); 
   double dHeight = cap.get(CV_CAP_PROP_FRAME_HEIGHT);
   cout << "Frame Size = " << dWidth << "x" << dHeight << endl;
   Size frameSize(static_cast<int>(dWidth), static_cast<int>(dHeight));
   VideoWriter oVideoWriter ("video.avi", CV_FOURCC('M','P','4','2'), 20, frameSize, true);
   if ( !oVideoWriter.isOpened() ) 
   {
        cout << "ERROR: Failed to write the video" << endl;
        return -1;
   }

    for(;;)
    {
        cap >> frame;
        bg.operator ()(frame,fore);
        bg.getBackgroundImage(back);
        cv::erode(fore,fore,cv::Mat());
        cv::dilate(fore,fore,cv::Mat());
        cv::findContours(fore,contours,CV_RETR_EXTERNAL,CV_CHAIN_APPROX_NONE);
        cv::drawContours(frame,contours,-1,cv::Scalar(0,0,255),2);
        cv::imshow("Frame",frame);

oVideoWriter.write(frame); 

        if(cv::waitKey(30) >= 0) break;
    }
    return 0;
}