export CLIENT_IP=127.0.0.1

gst-launch-1.0 nvcamerasrc fpsRange="30 30" intent=3 ! nvvidconv flip-method=6 ! 'video/x-raw(memory:NVMM), width=(int)960, height=(int)540, format=(string)I420, framerate=(fraction)30/1' ! omxh264enc control-rate=2 bitrate=4000000 ! 'video/x-h264, stream-format=(string)byte-stream' ! h264parse ! queue ! omxh264dec ! nvvidconv ! 'video/x-raw, format=(string)UYVY' ! videoconvert ! jpegenc quality=30 ! rtpjpegpay ! udpsink host=$CLIENT_IP port=5000 sync=false async=false

#include <opencv2/highgui/highgui.hpp>
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/features2d/features2d.hpp>
#include <opencv2/calib3d/calib3d.hpp>

using namespace cv;

int main(int, char**)
{
  VideoCapture input("./stream.sdp");
  if(!input.isOpened()){  // check if we succeeded                                                                                                                                                                     
    std::cout<< "open failed" << std::endl;
    return -1;
  }

  Mat img, img_gray;
  OrbFeatureDetector detector(7000);
  vector<KeyPoint> img_keypoints, car_keypoints;
  Mat img_descriptors, car_descriptors;

  input.read(img);
  Mat car;
  img(Rect(400, 320, 150, 100)).copyTo(car);

  detector(car, Mat(), car_keypoints, car_descriptors);
  drawKeypoints(car, car_keypoints, car);
  for(;;)
    {
      if(!input.read(img))
        break;
      detector(img, Mat(), img_keypoints, img_descriptors);
      drawKeypoints(img, img_keypoints, img);


      BFMatcher matcher;
      vector<DMatch> matches;
      matcher.match(car_descriptors, img_descriptors, matches);

      vector<Point2f> car_points, img_points;
      for(int i=0; i < matches.size(); ++i){
        car_points.push_back(car_keypoints[matches[i].queryIdx].pt);
        img_points.push_back(img_keypoints[matches[i].queryIdx].pt);
      }
      std::cout<<"car points count = " << car_points.size() << std::endl;

      if(car_points.size() >= 4){
        Matx33f H = findHomography(car_points, img_points, CV_RANSAC);

        vector<Point> car_border, img_border;
        car_border.push_back(Point(0, 0));
        car_border.push_back(Point(0, car.rows));
        car_border.push_back(Point(car.cols, car.rows));
        car_border.push_back(Point(car.cols, 0));
        for (size_t i = 0; i < car_border.size(); ++i){
          Vec3f p = H * Vec3f(car_border[i].x, car_border[i].y, 1);
          img_border.push_back(Point(p[0]/p[2], p[1]/p[2]));
        }
        polylines(img, img_border, true, CV_RGB(255, 255, 0));
        Mat img_matches;
        drawMatches(car, car_keypoints, img, img_keypoints, matches, img_matches);
        imshow("img_matches", img_matches);
      }
      // imshow("car", car);                                                                                                                                                                                           
      // imshow("img", img);                                                                                                                                                                                           
      if(waitKey(27) >= 0) break;
    }
  // the camera will be deinitialized automatically in VideoCapture destructor                                                                                                                                         
  return 0;
}

cmake_minimum_required(VERSION 2.8)

project(hello)

find_package(OpenCV REQUIRED)

include_directories(${OpenCV_INCLUDE_DIRS})

add_executable(cv_hello hello.cpp)

target_link_libraries(cv_hello ${OpenCV_LIBS})

[stream.sdp]
c=IN IP4 127.0.0.1
m=video 5000 RTP/AVP 96
a=rtpmap:96 JPEG/4000000

框架+演员=符号。演员之间传递消息，但是消息的解释取决于演员自己的特性，于是符号的内容将由框架和演员共同决定.演员是信号的启发器

副总统是政府这部汽车的备用轮胎。概念骨架不仅必须存在于不同的抽象层次上，还需要存在于不同概念“维度”上。

1.程序能否写出优美的乐曲？

会的，但不是现在。音乐是情感的语言，精神世界不可低估。能有如此能力的“程序”必须得能自己走进这个世界，在纷繁的世界中与生活抗争，并每时每刻体验到自己的感受。他必须懂得暗夜里凉风带来的喜悦与孤独，懂得对于带来温暖爱抚地手掌的渴望，还要能体验到一个人死去后引起的心碎与生活。明了放弃与厌世，悲伤与失望，决心与胜利，虔诚与敬畏。能把希望/恐惧/烦恼/欢乐/宁静/不安等对立的情绪混合到一起。。。。

2.是否可以在低层次设置核心参数控制程序？

不能，如同人不会在意自己每天死掉几千个神经原一样，我们几乎没事，除非你要给大脑做手术折腾的太厉害。但这已经不属于低层次控制

3.人工智能是否存在超智能？

可能和规模有关，我们也许有一个临界点，也许人类已经位于零界点之上。有一天会达到全能自我认知，即笛卡尔的“我思故我在”将演变为“我在思我所思”。

也许人工智能有一天达到了人类的智能，但是他会进入下一阶段。我们可能还不知道那是什么样的。

4.是否存在能击败任何人的下棋程序？

可能已经有，但是现在还只是下棋。

跳出下棋，普遍的去看，真正的只能必然依赖于一种纵览全局的能力---即可以说是在程序中编入了一种“跳出系统外”的能力。一旦实现了这一步，你就无法再完全控制这个程序了，他将超过一个特定的临界点，那时你不得不与你造出来的东西打交道。

1. 1、从图中某个顶点V0出发，并访问此顶点；
   2、从V0出发，访问V0的各个未曾访问的邻接点W1，W2，…,Wk;然后,依次从W1,W2,…,Wk出发访问各自未被访问的邻接点；
   3、重复步骤2，直到全部顶点都被访问为止。

extension String{
    func escapeSpaceTillCahractor()->String{
        return self.stringEscapeHeadTail(strs:["\r", " ", "\n"])
    }
    func escapeHeadStr(str:String)->(String, Bool){
        var result = self as NSString
        var findAtleastOne = false
        while( true ){
            var range = result.rangeOfString(str)
            if range.location == 0 && range.length == 1 {
                result = result.substringFromIndex(range.length)
                findAtleastOne = true
            }else{
                break
            }
        }
        return (result as String, findAtleastOne)
    }
    func escapeSpaceTillCahractor(#strs:[String])->String{
        var result = self
        while( true ){
            var findAtleastOne = false
            for str in strs {
                var found:Bool = false
                (result, found) = result.escapeHeadStr(str)
                if found {
                    findAtleastOne = true
                    break  //for循环
                }
            }
            if findAtleastOne == false {
                break
            }
        }
        return result as String
    }
    func reverse()->String{
        var inReverse = ""
        for letter in self {
            println(letter)
            inReverse = "\(letter)" + inReverse
        }
        return inReverse
    }

    func escapeHeadTailSpace()->String{
        return self.escapeSpaceTillCahractor().reverse().escapeSpaceTillCahractor().reverse()
    }

    func stringEscapeHeadTail(#strs:[String])->String{
        return self.escapeSpaceTillCahractor(strs:strs).reverse().escapeSpaceTillCahractor(strs:strs).reverse()
    }
}