[PYTHON] Détection de chat avec OpenCV (distribution de modèles)

(Ajouté le 2014/09)

J'écris également un article sur la façon d'identifier les races de chats à l'aide de techniques de Deep Learning. Veuillez vous référer si vous êtes intéressé.

• Identification de race de chat avec Deep Learning

Détection de chat avec OpenCV

(Chocolat-Kichijoji Chariko)

Cat and image processing part 1 - Collecting Materials a organisé comment collecter des images de chat, mais ici nous utilisons les images de chat collectées pour organiser les chats. J'ai créé un modèle d'apprentissage (classificateur) pour la détection.

Si vous êtes intéressé, les détails techniques sont écrits sur le blog. La distribution du modèle sera abordée plus loin dans cette entrée.

• Cat and image processing part 2-Cat detection

L'apprentissage se fait avec le Boosting familier (l'une des méthodes d'apprentissage d'ensemble). Pour la quantité de fonctionnalités, nous avons adopté la fonctionnalité LBP qui peut rapidement répéter la création et la vérification du modèle. En outre, environ 7 000 données d'annotation ont été collectées à l'aide de l'approvisionnement en nuage.

Comment utiliser

C++ À partir de C ++, utilisez-le comme suit.

// objdetect.cpp
#include <iostream>
#include <vector>
#include <opencv2/opencv.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/objdetect/objdetect.hpp>

int main(int argc, char** argv) {
  using namespace std;
  if(argc != 3) {
    cerr << "./objdetect [image file] [cascade file]" << endl;
    exit(-1);
  }
  cv::Mat src_img = cv::imread(argv[1], 1);
  if(src_img.empty()) {
    cerr << "cannot load image" << endl;
    exit(-1);
  }
  cv::Mat dst_img = src_img.clone();
  string cascade_file = string(argv[2]);
  cv::CascadeClassifier cascade;
  cascade.load(cascade_file);
  if(cascade.empty()) {
    cerr << "cannot load cascade file" << endl;
    exit(-1);
  }
  vector<cv::Rect> objects;
  cascade.detectMultiScale(src_img, objects, 1.1, 3);
  vector<cv::Rect>::const_iterator iter = objects.begin();
  cout << "count: " << objects.size() << endl;
  while(iter!=objects.end()) {
    cout << "(x, y, width, height) = (" << iter->x << ", " << iter->y << ", "
         << iter->width << ", " << iter->height << ")" << endl;
    cv::rectangle(dst_img,
                  cv::Rect(iter->x, iter->y, iter->width, iter->height),
                  cv::Scalar(0, 0, 255), 2);
    ++iter;
  }
  cv::imwrite("result.jpg ", dst_img);
  return 0;
}

##Compiler et exécuter
$ g++ -o objdetect objdetect.cpp -I/path/to/opencv/include -L/path/to/opencv/lib -lopencv_core -lopencv_highgui  -lopencv_objdetect
$ ./objdetect cat.jpg cascade.xml
count: 1
(x, y, width, height) = (278, 185, 65, 65)

Si vous spécifiez les paramètres au moment de la détection de manière lâche (définissez le paramètre minNeighbors sur une petite valeur), la précision de détection semble augmenter. Bien sûr, les faux positifs augmenteront, mais si vous ajoutez un traitement tel que l'exclusion des cas où la zone de détection est plus petite qu'une certaine taille (en spécifiant le paramètre minSize), vous pouvez lui donner un certain degré de précision.

CascadeClassifier::detectMultiScale - docs.opencv.org

Python Facile à utiliser depuis Python.

#!/usr/local/bin/python
# -*- coding: utf-8 -*-

import sys
import cv2 as cv

def detect(imagefilename, cascadefilename):
    srcimg = cv.imread(imagefilename)
    if srcimg is None:
        print('cannot load image')
        sys.exit(-1)
    dstimg = srcimg.copy()
    cascade = cv.CascadeClassifier(cascadefilename)
    if cascade.empty():
        print('cannnot load cascade file')
        sys.exit(-1)
    objects = cascade.detectMultiScale(srcimg, 1.1, 3)
    for (x, y, w, h) in objects:
        print(x, y, w, h)
        cv.rectangle(dstimg, (x, y), (x + w, y + h), (0, 0, 255), 2)
    return dstimg

if __name__ == '__main__':
    result = detect('cat.jpg', 'cascade.xml')
    cv.imwrite('result.jpg', result)

Distribution du modèle

Je publierai le modèle que j'ai réalisé cette fois. Un fichier en cascade (cascade.xml) qui peut être lu par OpenCV.

• cat detection cascade model - wellflat/cat-fancier

Étant donné que le processus par lots qui détecte le nouvel ajout de données d'enseignant à la base de données et exécute l'apprentissage s'exécute sur le serveur personnel, il doit être mis à jour en continu et automatiquement vers un modèle plus précis.

Cela dit, si aucune mesure n'est prise, la précision atteindra un plateau, donc je pense que l'algorithme sera amélioré en ajoutant divers pré-traitements et post-traitements.

• Cat and image processing part 1 - Collecting Materials
• Cat and image processing part 2-Cat detection