exit()

윈도우랑 우분투랑 복사 붙여넣기가 안되어서

오늘은 vmware tools 설치해볼겁니다.

가상머신에서만 설치가 된다고 알고 있습니다.

VMware Workstation 12 Player Ubuntu 16.04입니다.

Player - Manage - Install VMware tools 를 선택해주면 다음과 같은 화면이 자동으로 뜹니다.

알집파일을 마우스 오른쪽 버튼으로 Extract to 를 선택해주고 Desktop 에 압축을 풀어줍니다.

바탕화면에 저렇게 폴더가 생기는데 폴더를 열어서

vmware-install.pl 파일을 터미널창에 드래그 해서 가져다놓습니다.

다시 하느라 터미널 창에 아무것도 안쓰여져 있는데 이때

sudo su 를 해서 관리자권한으로 진입해준뒤 드래그해줍니다.

no 빼고 다 엔터쳐주면 조금 버벅이면서 완료됩니다.

restart 해주면 설치 완료됩니다.

칼만필터를 이용해서 얼굴 중심점 찾는 코딩을 해봤는데

필터를 이용해 원을 그리면 원의 반경이 점점 커지더라고요.

그래서 그냥 원의 반경을 고정시켜놓고 하였습니다.

#include "ardrone/ardrone.h"

#include <iostream>

// --------------------------------------------------------------------------
// main(Number of arguments, Argument values)
// Description  : This is the entry point of the program.
// Return value : SUCCESS:0  ERROR:-1
// --------------------------------------------------------------------------
int main(int argc, char *argv[])
{
    // AR.Drone class
    ARDrone ardrone;

   cv::CascadeClassifier face_classifier;

   face_classifier.load("C:/Users/hayoon/Downloads/opencv/sources/data/haarcascades/haarcascade_frontalface_alt.xml");

    // Initialize
    if (!ardrone.open()) {
        std::cout << "Failed to initialize." << std::endl;
        return -1;
    }

    // Battery
    std::cout << "Battery = " << ardrone.getBatteryPercentage() << "[%]" << std::endl;

    // Instructions
    std::cout << "***************************************" << std::endl;
    std::cout << "*       CV Drone sample program       *" << std::endl;
    std::cout << "*           - How to play -           *" << std::endl;
    std::cout << "***************************************" << std::endl;
    std::cout << "*                                     *" << std::endl;
    std::cout << "* - Controls -                        *" << std::endl;
    std::cout << "*    'Space' -- Takeoff/Landing       *" << std::endl;
    std::cout << "*    'Up'    -- Move forward          *" << std::endl;
    std::cout << "*    'Down'  -- Move backward         *" << std::endl;
    std::cout << "*    'Left'  -- Turn left             *" << std::endl;
    std::cout << "*    'Right' -- Turn right            *" << std::endl;
    std::cout << "*    'Q'     -- Move upward           *" << std::endl;
    std::cout << "*    'A'     -- Move downward         *" << std::endl;
    std::cout << "*                                     *" << std::endl;
    std::cout << "* - Others -                          *" << std::endl;
    std::cout << "*    'C'     -- Change camera         *" << std::endl;
    std::cout << "*    'Esc'   -- Exit                  *" << std::endl;
    std::cout << "*                                     *" << std::endl;
    std::cout << "***************************************" << std::endl;

   // Kalman filter
   cv::KalmanFilter kalman(4, 2, 0);

   // Sampling time [s]
   const double dt = 1.0;

   // Transition matrix (x, y, vx, vy)
   cv::Mat1f A(4, 4);
   A << 1.0, 0.0, dt, 0.0,
      0.0, 1.0, 0.0, dt,
      0.0, 0.0, 1.0, 0.0,
      0.0, 0.0, 0.0, 1.0;
   kalman.transitionMatrix = A;

   // Measurement matrix (x, y)
   cv::Mat1f H(2, 4);
   H << 1, 0, 0, 0,
      0, 1, 0, 0;
   kalman.measurementMatrix = H;

   // Process noise covariance (x, y, vx, vy)
   cv::Mat1f Q(4, 4);
   Q << 1e-5, 0.0, 0.0, 0.0,
      0.0, 1e-5, 0.0, 0.0,
      0.0, 0.0, 1e-5, 0.0,
      0.0, 0.0, 0.0, 1e-5;
   kalman.processNoiseCov = Q;

   // Measurement noise covariance (x, y)
   cv::Mat1f R(2, 2);
   R << 1e-1, 0.0,
      0.0, 1e-1;
   kalman.measurementNoiseCov = R;

   while (1) {
      bool frame_valid = true;

      // Key input
      int key = cv::waitKey(33);
      if (key == 0x1b) break;

      // Get an image
      cv::Mat image = ardrone.getImage();

      cv::Mat frame = image.clone();

      // Take off / Landing
      if (key == ' ') {
         if (ardrone.onGround()) ardrone.takeoff();
         else                    ardrone.landing();
      }

      // Move
      double vx = 0.0, vy = 0.0, vz = 0.0, vr = 0.0;
      if (key == 'i' || key == CV_VK_UP)    vx = 1.0;
      if (key == 'k' || key == CV_VK_DOWN)  vx = -1.0;
      if (key == 'u' || key == CV_VK_LEFT)  vr = 1.0;
      if (key == 'o' || key == CV_VK_RIGHT) vr = -1.0;
      if (key == 'j') vy = 1.0;
      if (key == 'l') vy = -1.0;
      if (key == 'q') vz = 1.0;
      if (key == 'a') vz = -1.0;
      ardrone.move3D(vx, vy, vz, vr);

      // Change camera
      static int mode = 0;
      if (key == 'c') ardrone.setCamera(++mode % 4);

      if (frame_valid) {
         try {
            // convert captured frame to gray scale & equalize
            cv::Mat grayframe;
            cv::cvtColor(frame, grayframe, CV_BGR2GRAY);
            cv::equalizeHist(grayframe, grayframe);

            // -------------------------------------------------------------
            // face detection routine

            // a vector array to store the face found
            std::vector<cv::Rect> faces;

            face_classifier.detectMultiScale(grayframe, faces,
               1.1, // increase search scale by 10% each pass
               3,   // merge groups of three detections
               CV_HAAR_FIND_BIGGEST_OBJECT | CV_HAAR_SCALE_IMAGE,
               cv::Size(30, 30)
               );

            // -------------------------------------------------------------

            // Prediction
            cv::Mat1f prediction = kalman.predict();
            int radius = 1e+3 * kalman.errorCovPre.at<float>(0, 0);
           
            // draw the results
            for (int i = 0; i < faces.size(); i++) {
               cv::Point lb(faces[i].x + faces[i].width, faces[i].y + faces[i].height);
               cv::Point tr(faces[i].x, faces[i].y);

               cv::rectangle(frame, lb, tr, cv::Scalar(0, 255, 0), 3, 4, 0);
        
               cv::Point center(faces[i].x + faces[i].width*0.5, faces[i].y + faces[i].height*0.5);
           
               cv::circle(frame, center, 10, cv::Scalar(0, 255, 0), 2);
            }
           
            // Display the image
            //cv::imshow("camera", image);
            cv::imshow("webcam", frame);
         }
         catch (cv::Exception& e) {
            std::cerr << "Exception occurred. Ignoring frame... " << e.err << std::endl;
         }
      }
   }

    // See you
    ardrone.close();

    return 0;
}

#include "ardrone/ardrone.h"

#include <vector>

#include <iostream>

// --------------------------------------------------------------------------

// main(Number of arguments, Argument values)

// Description  : This is the entry point of the program.

// Return value : SUCCESS:0  ERROR:-1

// --------------------------------------------------------------------------

int main(int argc, char *argv[])

{

// AR.Drone class

ARDrone ardrone;

// Initialize

if (!ardrone.open()) {

std::cout << "Failed to initialize." << std::endl;

return -1;

}

// Battery

std::cout << "Battery = " << ardrone.getBatteryPercentage() << "[%]" << std::endl;

// Instructions

std::cout << "***************************************" << std::endl;

std::cout << "*       CV Drone sample program       *" << std::endl;

std::cout << "*           - How to play -           *" << std::endl;

std::cout << "***************************************" << std::endl;

std::cout << "*                                     *" << std::endl;

std::cout << "* - Controls -                        *" << std::endl;

std::cout << "*    'Space' -- Takeoff/Landing       *" << std::endl;

std::cout << "*    'Up'    -- Move forward          *" << std::endl;

std::cout << "*    'Down'  -- Move backward         *" << std::endl;

std::cout << "*    'Left'  -- Turn left             *" << std::endl;

std::cout << "*    'Right' -- Turn right            *" << std::endl;

std::cout << "*    'Q'     -- Move upward           *" << std::endl;

std::cout << "*    'A'     -- Move downward         *" << std::endl;

std::cout << "*                                     *" << std::endl;

std::cout << "* - Others -                          *" << std::endl;

std::cout << "*    'C'     -- Change camera         *" << std::endl;

std::cout << "*    'Esc'   -- Exit                  *" << std::endl;

std::cout << "*                                     *" << std::endl;

std::cout << "***************************************" << std::endl;

while (1) {

// Key input

int key = cv::waitKey(33);

if (key == 0x1b) break;

// Get an image

cv::Mat image = ardrone.getImage();

cv::Mat frame = image.clone();

//방법1.

//반복문으로 각 화소 모두 비교하는 방법

//컬러 공간 변환 BGR->YCrCb

cv::Mat YCrCb;

cvtColor(frame, YCrCb, CV_BGR2YCrCb);

//각 채널별로 분리

std::vector<cv::Mat> planes;

cv::split(YCrCb, planes);

cv::Mat mask = (128 < planes[1]) & (planes[1] < 170) & (73 < planes[2]) & (planes[2] < 158);

erode(mask, mask, cv::Mat(3, 3, CV_8U, cv::Scalar(1)), cv::Point(-1, -1), 2);

// Take off / Landing 

if (key == ' ') {

if (ardrone.onGround()) ardrone.takeoff();

else                    ardrone.landing();

}

// Move

double vx = 0.0, vy = 0.0, vz = 0.0, vr = 0.0;

if (key == 'i' || key == CV_VK_UP)    vx = 1.0;

if (key == 'k' || key == CV_VK_DOWN)  vx = -1.0;

if (key == 'u' || key == CV_VK_LEFT)  vr = 1.0;

if (key == 'o' || key == CV_VK_RIGHT) vr = -1.0;

if (key == 'j') vy = 1.0;

if (key == 'l') vy = -1.0;

if (key == 'q') vz = 1.0;

if (key == 'a') vz = -1.0;

ardrone.move3D(vx, vy, vz, vr);

// Change camera

static int mode = 0;

if (key == 'c') ardrone.setCamera(++mode % 4);

// Display the image

cv::imshow("camera", image);

cv::imshow("humancamera", mask);

}

// See you

ardrone.close();

return 0;

}

#include <iostream>

#include <opencv2/opencv.hpp>

#include <stdlib.h>

#include <stdio.h>

using namespace std;

using namespace cv;

/* @ function main */

int main(int argc, char *argv[])

{

   // open the default camera

   cv::VideoCapture cap(0);

   // check if we succeeded

   if (!cap.isOpened()) {

      std::cerr << "Could not open camera" << std::endl;

      return -1;

   }

   // create a window

   cv::namedWindow("webcam", 1);

   // face detection configuration

   cv::CascadeClassifier face_classifier;

   face_classifier.load("C:/opencv/sources/data/haarcascades/haarcascade_frontalface_alt.xml");

   cv::Mat frame;

   while(1) {

      bool frame_valid = true;

      try {

         // get a new frame from webcam

         cap >> frame;

      }

      catch (cv::Exception& e) {

         std::cerr << "Exception occurred. Ignoring frame... " << e.err << std::endl;

         frame_valid = false;

      }

      if (frame_valid) {

         try {

            // convert captured frame to gray scale & equalize

            cv::Mat grayframe;

            cv::cvtColor(frame, grayframe, CV_BGR2GRAY);

            cv::equalizeHist(grayframe, grayframe);

            // -------------------------------------------------------------

            // face detection routine

            // a vector array to store the face found

            std::vector<cv::Rect> faces;

            face_classifier.detectMultiScale(grayframe, faces,

               1.1, // increase search scale by 10% each pass

               3,   // merge groups of three detections

               CV_HAAR_FIND_BIGGEST_OBJECT | CV_HAAR_SCALE_IMAGE,

               cv::Size(30, 30)

            );

            // -------------------------------------------------------------

            // draw the results

            for (int i = 0; i < faces.size(); i++) {

               cv::Point lb(faces[i].x + faces[i].width, faces[i].y + faces[i].height);

               cv::Point tr(faces[i].x, faces[i].y);

               cv::rectangle(frame, lb, tr, cv::Scalar(0, 255, 0), 3, 4, 0);

            }

            // print the output

            cv::imshow("webcam", frame);

         }

         catch (cv::Exception& e) {

            std::cerr << "Exception occurred. Ignoring frame... " << e.err << std::endl;

         }

      }

      if (cv::waitKey(30) == 10) break;

   }

   // VideoCapture automatically deallocate camera object

   return 0;

}

드론 카메라의 영상을 받아오는 데 있어서 많은 시도를 해보았습니다.

1. Linux 기반의 Python 코드 이용

2. Linux 기반의 SDK 응용

3. Windows 기반의 C++ 코드 이용

4. Windows 기반의 자바스크립트 이용

2일 동안 여러 가지 시도를 해보았고 3. Windows 기반의 C++ 코드로 영상을 받아오는 데 성공하였습니다.

https://github.com/puku0x/cvdrone

위 사이트에서 Clone or download를 클릭해서 Download ZIP을 해줍니다.

 다운로드한 ZIP 파일을 압축 해제해서 /build/vs20xx/test.sln(솔루션파일) 을 열어줍니다.

vs20xx는 PC의 비주얼 버전을 말합니다. 저는 2013을 사용하였습니다.

F7 키로 build를 해주고, F5키로 컴파일을 해주면 드론의 영상을 받아올 수 있습니다.

드론 제어 또한 가능한 코드입니다.

OpenCV 설치

일단 기본 라이브러리 설치

$ sudo apt-get update

$ sudo apt-get install libopencv-dev build-essential checkinstall cmake pkg-config yasm libtiff4-dev libjpeg-dev libjasper-dev libavcodec-dev libavformat-dev libswscale-dev libdc1394-22-dev libxine-dev libgstreamer0.10-dev libgstreamer-plugins-base0.10-dev libv4l-dev python-dev python-numpy libtbb-dev libqt4-dev libgtk2.0-dev libfaac-dev libmp3lame-dev libopencore-amrnb-dev libopencore-amrwb-dev libtheora-dev libvorbis-dev libxvidcore-dev x264 v4l-utils ffmpeg 

ffmpeg이 설치가 안되면 

$ sudo add-apt-repository ppa:mc3man/trusty-media

$ sudo apt-get update

$ sudo apt-get dist-upgrade

$ sudo apt-get install ffmpeg

차례대로 해준다.

지금은 3.1 까지 나와있지만

나는 2.x 대로 작업하기 때문에 2.4.13 을 설치한다.

git으로 다운받으면 항상 최신버전이기 때문에 나는 직접 다운을 받는다. 

git clone 다운 시

$ git clone https://github.com/Itseez/opencv/

https://github.com/Itseez/opencv/archive/2.4.13.zip

링크로 다운받을 수 있다.

다운받으면 보통은 ~/Downloads 에 저장된다.

$ cd ~/Downloads

$ unzip opencv-2.4.13.zip 

$ cd opencv-2.4.13

$ mkdir release

$ cd release

$ cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D WITH_TBB=ON -D BUILD_NEW_PYTHON_SUPPORT=ON -D WITH_V4L=ON -D INSTALL_C_EXAMPLES=ON -D INSTALL_PYTHON_EXAMPLES=ON -D BUILD_EXAMPLES=ON -D WITH_QT=ON -D WITH_OPENGL=ON -D ENABLE_FAST_MATH=1 -D CUDA_FAST_MATH=1 -D WITH_CUBLAS=1  -DBUILD_TIFF=ON ..

$ make

-j 옵션을 써서 속도를 향상시킬 수 있다.

make에 사용될 코어의 수이다.

ex) make -j4 => cpu 코어 4개 사용

ex) make -j8 => cpu 코어 8개 사용

저는 -j8을 해주었습니다. 시간이 꽤 오래 걸려요

$ sudo make install

anaconda를 사용하는 경우

$ cd ~/anaconda/lib/python2.7/site-packages/

$ ln -s /usr/local/lib/python2.7/site-packages/cv2.so cv2.so

를 추가로 해준다.

출처: http://hanmaruj.tistory.com/13 [하늘마루 이야기]

opencv 설치하기에 앞서 visual studio는 2013버전으로 설치해주었습니다.

C에서와 마찬가지로 프로젝트를 실행시켜주는데 .c가 아닌 원래의 .cpp로 프로젝트를 열어줍니다.

C에서 하듯이 source에 new item을 추가해주고, 프로젝트의 property를 열어줍니다.

C/C++ - General - Additional Included Directories에 opencv 폴더들을 추가해줍니다.

(opencv 파일이 필요하신 분은 댓글 남겨주세요)

Linker - General - Additional Library Directories 에 opencv 폴더의 x64 - lib를 추가해줍니다.

Linker - Input - Additional Dependencies에 필요한 opencv library들을 추가해줍니다.

debug를 해줍니다.

(코드가 필요하신 분은 댓글 남겨주세요)

dll 에러가 발생합니다.

Visual Studio 2013 - Projects - (프로젝트 명) 의 Source 파일이 있는 폴더에 opencv의 dll 파일들을 추가해줍니다.

다시 debug를 해주면 노트북의 영상을 따올 수 있습니다.

먼저 윈도우 상에 우분투를 설치하기 위해 필요한 파일들 입니다.

같이 팀블로그를 운영하는 지훈님이 올려주실 거예요.ㅋㅋㅋ

vmware workstation 12 player를 실행시켜서 다음과 같이 다운로드 해줍니다.

이렇게 하고나면 vmware workstation이 생성됩니다.

실행을 시켜주면 다음과 같은 화면이 뜹니다.

처음 실행시키시면 Home만 있고 우분투가 없을텐데요.

이때 create a new virtual machine을 클릭한 뒤 다음과 같이 진행해줍니다.

2~3분뒤에 설치가 완료됩니다!

비밀번호를 치고 들어가면 아직 터미널창이 없는데요.

제일 위에 아이콘을 눌러서 terminal을 검색해줍니다.

그리고 Terminal 아이콘을 끌어다 왼쪽 탭에 고정시키면 됩니다.

저주파 통과 필터를 적용하게 되면 이전의 데이터 평균 값에 비해

최근의 데이터에 더 높은 가중치를 둘 수 있습니다.

const int ECHO=9;
const int TRIG=10;

#define SIZE 50

int buffer[SIZE];

float duration, Cm;
float sum;
float distance;
float preDistance;
float Cm1, duration1;
float alpha=0.7;

void setup() {
  Serial.begin(9600);
  Serial.flush();
  pinMode(TRIG,OUTPUT);
  pinMode(ECHO,INPUT);
  digitalWrite(TRIG,LOW);

  Cm=duration/(29.1*2);
  sum=0;

  for(int i=0; i<=SIZE-1; i++)
  {
    digitalWrite(TRIG,HIGH);
    delayMicroseconds(10);
    digitalWrite(TRIG,LOW);
    duration=pulseIn(ECHO,HIGH);
    buffer[i]=Cm;
    if(Cm>400) Cm=400;
    else if(Cm<2) Cm=2;
    sum+=buffer[i];
  }
  preDistance=sum/SIZE;
}

void loop() {
  digitalWrite(TRIG,HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG,LOW);
  duration1=pulseIn(ECHO,HIGH);
  Cm1=duration1/58.8;

  distance=alpha*preDistance+(1-alpha)*Cm1;

  if(distance>400) distance=400;
  else if(distance<2) distance=2;

  Serial.println((int)distance);
  delay(5);

  preDistance=distance;
}

업로드 한 후 결과를 살펴보면 중간에 생기던 잡음이 제거되며 또한 물체와 센서 사이의 거리가 갑자기 바뀌더라도 정확하게 측정될 것입니다.