2014年2月27日木曜日

iosアプリのアイコン必要画像一覧

・アプリアイコン
iTunesArtwork@2x.png  1024×1024 px
iTunesArtwork.png    512×512
appicon-xxxhdpi.png    196×196
appicon-xxhdpi.png     176×176
appicon-76@2x.png     152×152
appicon-72@2x.png     144×144
appicon@2x.png       120×120
appicon-114.png       114×114
appicon-76.png        76×76
appicon-72.png        72×72
appicon.png         57×57
 
・スプラッシュスクリーン
Default-Landscape@2x.png   2048(横)x1536(縦)
Default-Portrait@2x.png    1536×2048
Default-Landscape.png    1024×768
Default-Portrait.png      768×1024
Default-568h@2x.png     640×1136
Default@2x.png       640×960 
Default.png         320×480
 
・ナビゲーションバー背景画像
navbar@2x.png      640×88
navbar.png        320×44
navbar-ipad@2x.png    1536×88
navbar-ipad.png      768×44

スレッドの作り方

unsigned thID;
HANDLE hTh;
hTh = (HANDLE)_beginthreadex(NULL, 0, scanPaperThread, NULL, 0, &thID);

if (hTh != NULL) {
  CloseHandle(hTh);
  printf("ハンドルクローズしました\n");
}

unsigned __stdcall scanPaperThread(void *lpx)
{

かえるの歌

18,17,16,15,16,17,18,16,15,14,13,14,15,16,18,18,18,18,18,17,16,15,16,17,18

きらきら星

18,18,14,14,13,13,14,14,15,15,16,16,17,17,18,18,14,14,15,15,16,16,17,17,14,14,15,15,16,16,17,17,18,18,14,14,13,13,14,14,15,15,16,16,17,17,18,18

Excelマクロ

Function test(hoge As String)
    If hoge = "ど" Then
        test = 18
    ElseIf hoge = "れ" Then
        test = 17
    ElseIf hoge = "み" Then
        test = 16
    ElseIf hoge = "ふぁ" Then
        test = 15
    ElseIf hoge = "そ" Then
        test = 14
    ElseIf hoge = "ら" Then
        test = 13
    ElseIf hoge = "し" Then
        test = 12
    End If
End Function


sin波

AudioOutputUnitStop(aU);
-(void)playSound{
    
    //Sampling rate
    _sampleRate = 44100.0f;
    
    //Bit rate
    bitRate = 8// 8bit
    

    //AudioComponentDescription
    AudioComponentDescription aCD;
    aCD.componentType = kAudioUnitType_Output;
    aCD.componentSubType = kAudioUnitSubType_RemoteIO;
    aCD.componentManufacturer = kAudioUnitManufacturer_Apple;
    aCD.componentFlags = 0;
    aCD.componentFlagsMask = 0;
    
    //AudioComponent
    AudioComponent aC = AudioComponentFindNext(NULL, &aCD);
    AudioComponentInstanceNew(aC, &aU);
    AudioUnitInitialize(aU);
    
    //コールバック
    AURenderCallbackStruct callbackStruct;
    callbackStruct.inputProc = renderer;
    callbackStruct.inputProcRefCon = (__bridge void*)self;
    AudioUnitSetProperty(aU,
                         kAudioUnitProperty_SetRenderCallback,
                         kAudioUnitScope_Input,
                         0,
                         &callbackStruct,
                         sizeof(AURenderCallbackStruct));
    
    //AudioStreamBasicDescription
    AudioStreamBasicDescription aSBD;
    aSBD.mSampleRate = _sampleRate;
    aSBD.mFormatID = kAudioFormatLinearPCM;
    aSBD.mFormatFlags = kAudioFormatFlagsAudioUnitCanonical;
    aSBD.mChannelsPerFrame = 2;
    aSBD.mBytesPerPacket = sizeof(AudioUnitSampleType);
    aSBD.mBytesPerFrame = sizeof(AudioUnitSampleType);
    aSBD.mFramesPerPacket = 1;
    aSBD.mBitsPerChannel = bitRate * sizeof(AudioUnitSampleType);
    aSBD.mReserved = 0;
    
    //AudioUnit
    AudioUnitSetProperty(aU,
                         kAudioUnitProperty_StreamFormat,
                         kAudioUnitScope_Input,
                         0,
                         &aSBD,
                         sizeof(aSBD));
    

    
    //再生
    AudioOutputUnitStart(aU);

    
}

static OSStatus renderer(void *inRef,
                         AudioUnitRenderActionFlags *ioActionFlags,
                         const AudioTimeStamp* inTimeStamp,
                         UInt32 inBusNumber,
                         UInt32 inNumberFrames,
                         AudioBufferList *ioData) {
    
    //キャスト
    ViewController* def = (__bridge ViewController*)inRef;
    
    //サイン波
    float freq = def.frequency*2.0*M_PI/def.sampleRate;
    
    //値を書き込むポインタ
    AudioUnitSampleType *outL = ioData->mBuffers[0].mData;
    AudioUnitSampleType *outR = ioData->mBuffers[1].mData;
    
    for (int i = 0; i < inNumberFrames; i++) {
        // 周波数を計算
        float wave = sin(def.phase);
        AudioUnitSampleType sample = wave * (1 << kAudioUnitSampleFractionBits);
        *outL++ = sample;
        *outR++ = sample;
        def.phase += freq;
    }
    
    return noErr;
    

};

周波数指定

 switch (button.tag) {
        case 19: //
            _frequency = 246.94;
            break;
        case 18: //
            _frequency = 261.62;
            break;
        case 17: //
            _frequency = 293.66;
            break;
        case 16: //
            _frequency = 329.62;
            break;
        case 15: //ファ
            _frequency = 349.22;
            break;
        case 14: //
            _frequency = 391.99;
            break;
        case 13: //
            _frequency = 440.00;
            break;
        case 12: //
            _frequency = 493.88;
            break;
        case 11: //
            _frequency = 523.25;
            break;
        case 10: //
            _frequency = 587.32;//293.66;
            break;
        case 9: //
            _frequency = 659.25;//329.62;
            break;
        case 8: //ファ
            _frequency = 698.45;//349.22;
            break;
        case 7: //
            _frequency = 783.99;//391.99;
            break;
        case 6: //
            _frequency = 880.00;//440.00;
            break;
        case 5: //
            _frequency = 987.76;//493.88;
            break;
        case 4: //
            _frequency = 1046.50;//523.25;
            break;
        case 3: //
            _frequency = 1174.65;//293.66;
            break;
        case 2: //
            _frequency = 1318.51;//329.62;
            break;
        case 1: //ファ
            _frequency = 1396.91;//349.22;
            break;
        case 0: //
            _frequency = 1567.98;//391.99;
            break;
        case 20: //
            _frequency = 1661.21;
            break;
        case 21: //ファ
            _frequency = 1479.97;//391.99;
            break;
        case 23: //
            _frequency =1244.50;//391.99;
            break;
        case 24: //
            _frequency = 1108.73;//391.99;
            break;
        case 26: //
            _frequency = 932.32;//391.99;
            break;
        case 27: //
            _frequency = 830.60;//391.99;
            break;
        case 28: //ファ
            _frequency = 739.98;//391.99;
            break;
        case 30: //
            _frequency = 622.25;//391.99;
            break;
        case 31: //
            _frequency = 554.36;//391.99;
            break;
        case 33: //
            _frequency = 466.16;//391.99;
            break;
        case 34: //
            _frequency = 415.30;//391.99;
            break;
        case 35: //ファ
            _frequency = 369.99;//391.99;
            break;
        case 37: //
            _frequency = 311.12;//391.99;
            break;
        case 38: //
            _frequency = 277.18;//391.99;
            break;
        case 40: //
            _frequency = 233.08;//391.99;
            break;


            
        default:
            break;

    }

回転禁止

- (BOOL)shouldAutorotate
{
    return NO;
}
- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)toInterfaceOrientation {
return UIInterfaceOrientationIsPortrait(toInterfaceOrientation);
}

2014年2月16日日曜日

テンプレートマッチング

TemplateMatching.h
--------------------------

#pragma once
#include "cvbase.h"
class TemplateMatching :
public CVBase
{
public:
TemplateMatching(void);
~TemplateMatching(void);
void mainloop(void);
};



TemplateMatching.cpp
--------------------------
#include "TemplateMatching.h"


TemplateMatching::TemplateMatching(void)
{
}


TemplateMatching::~TemplateMatching(void)
{
}

void TemplateMatching::mainloop(void)
{
cv::Mat search_img = cv::imread("room7.png", 1);
  if(search_img.empty()) return;
  // テンプレート画像
  cv::Mat tmp_img = cv::imread("room7_tmp_2.png", 1);
  if(tmp_img.empty()) return;

  cv::Mat result_img;
  // テンプレートマッチング
  cv::matchTemplate(search_img, tmp_img, result_img, CV_TM_CCOEFF_NORMED);

  // 最大のスコアの場所を探す
  cv::Rect roi_rect(0, 0, tmp_img.cols, tmp_img.rows);
  cv::Point max_pt;
  double maxVal;
  cv::minMaxLoc(result_img, NULL, &maxVal, NULL, &max_pt);
  roi_rect.x = max_pt.x;
  roi_rect.y = max_pt.y;
  std::cout << "(" << max_pt.x << ", " << max_pt.y << "), score=" << maxVal << std::endl;
  // 探索結果の場所に矩形を描画
  cv::rectangle(search_img, roi_rect, cv::Scalar(0,0,255), 3);

  cv::namedWindow("search image", CV_WINDOW_AUTOSIZE|CV_WINDOW_FREERATIO);
  cv::namedWindow("result image", CV_WINDOW_AUTOSIZE|CV_WINDOW_FREERATIO);
  cv::imshow("search image", search_img);
  cv::imshow("result image", result_img);
  cv::waitKey(0);
}

指定エリア内のカラー平均グラフの生成

ManyAreaValue.h
--------------------------------

#pragma once
#include "cvbase.h"
#include <vector>

using namespace std;

class Area
{
public:
Area(void);
CvPoint start;
CvPoint end;
int sum[3];
int before[3];
};
class ManyAreaValue :
public CVBase
{
public:
ManyAreaValue(void);
~ManyAreaValue(void);
vector<Area *> areas;
CvPoint pStart;
int speed;

IplImage *graph;

FILE *fp;
cv::VideoCapture cap;
bool mouse;

int count;
int position;
void mouseEvent (int event, int x, int y, int flags, void *param);
void mouseEvent2 (int event, int x, int y, int flags, void *param);
void init(void);
void mainloop(void);

CvScalar createColor(int colorNum);

//void term(void);

void calucurateAreaRGB(IplImage *img);
void printAreaRGB(void);


};



ManyAreaValue.cpp
-----------------------------

#include "ManyAreaValue.h"

void on_mouse (int event, int x, int y, int flags, void *param = NULL);
void on_mouse2 (int event, int x, int y, int flags, void *param = NULL);

Area::Area(void)
{
for (int j=0;j<3;j++){
this->sum[j] = -1;
}

}

ManyAreaValue::ManyAreaValue(void)
{
count = 0;
graph = cvCreateImage( cvSize( 1200, 255*4), IPL_DEPTH_8U, 3);
for (int i=0;i<4;i++){
cvLine (graph, cvPoint(0,255*i), cvPoint(1200,255*i), CV_RGB (    0,  0,  0), 1, CV_AA, 0);
cvLine (graph, cvPoint(0,255*i+100), cvPoint(1200,255*i+100), CV_RGB (    100,  100,  100), 1, CV_AA, 0);
cvLine (graph, cvPoint(0,255*i+200), cvPoint(1200,255*i+200), CV_RGB (    100,  100,  100), 1, CV_AA, 0);
}
}

ManyAreaValue::~ManyAreaValue(void)
{
}

void ManyAreaValue::mouseEvent (int event, int x, int y, int flags, void *param)
{
switch (event) {
case CV_EVENT_MOUSEMOVE:
break;
case CV_EVENT_LBUTTONDOWN:
pStart.x = x;
pStart.y = y;
break;
case CV_EVENT_LBUTTONUP:
Area *area = new Area();
CvPoint pEnd;
area->end.x = x;
area->end.y = y;
area->start = pStart;
areas.push_back(area);
break;
}
}

void ManyAreaValue::mouseEvent2 (int event, int x, int y, int flags, void *param)
{
switch (event) {
case CV_EVENT_MOUSEMOVE:
break;
case CV_EVENT_LBUTTONDOWN:
break;
case CV_EVENT_LBUTTONUP:
int setPos = (int)position/1200;
setPos += x;
count = x;
position = setPos;
cvSetCaptureProperty( this->capture, CV_CAP_PROP_POS_FRAMES, setPos*speed );
//frameNum = x*10;
break;
}
}

void ManyAreaValue::calucurateAreaRGB(IplImage *img)
{
for (int i=0;i<areas.size();i++){
uchar p[3];
for (int j=0;j<3;j++){
areas[i]->before[j] = areas[i]->sum[j] ;
areas[i]->sum[j] = 0;
}
int areaSize = (areas[i]->end.y-areas[i]->start.y) * (areas[i]->end.x-areas[i]->start.x);
for (int y = areas[i]->start.y; y < areas[i]->end.y; y++) {
for (int x = areas[i]->start.x; x < areas[i]->end.x; x++) {
for (int j=0;j<3;j++){
p[0] = img->imageData[img->widthStep * y + x * 3 + 2 - j];
areas[i]->sum[j] += p[0];
}
}
}
for (int j=0;j<3;j++){
areas[i]->sum[j] /= areaSize;
}
}
}

CvScalar ManyAreaValue::createColor(int colorNum)
{
if (colorNum == 0){
return CV_RGB (  255,    0,  0);
}else if(colorNum == 1){
return CV_RGB (    0,  255,  0);
}else if (colorNum == 2){
return CV_RGB (    0,    0, 255);
}
return CV_RGB (    255,  255, 255);
}

void ManyAreaValue::printAreaRGB(void)
{
double msec = cvGetCaptureProperty(this->capture,CV_CAP_PROP_POS_MSEC);
fprintf(this->fp,"%lf,",msec);
for (int i=0;i<areas.size();i++){
for (int j=0;j<3;j++){
if (areas[i]->before[j] !=-1){

cvLine(graph,
cvPoint(count-1,255*i),
cvPoint(count,255*i+255),
CV_RGB (    0,  0,  0),
2, CV_AA, 0);
fprintf(this->fp,"%d,",areas[i]->sum[j]);
cvLine (graph,
cvPoint(count-1,255*i+areas[i]->before[j]),
cvPoint(count,255*i+areas[i]->sum[j]),
createColor(j),
2, CV_AA, 0);
}
}
}
fprintf(this->fp,"\n");
cvShowImage ("Graph",this->graph);
}

void ManyAreaValue::init(void)
{
FILE *initfp;
initfp = fopen("ini/ManyAreaValue.txt", "r");
char fileName[256];
int mode;
fscanf(initfp,"%d",&mode);
if (mode == 1){
fscanf(initfp,"%s",&fileName);
fscanf(initfp,"%d",&speed);
this->capture = cvCaptureFromFile(fileName);//"C:\\Users\\aiko\\Documents\\Visual Studio 2010\\Projects\\OpenCVBase\\1_01_H_131129153000.avi");
int areaNum;
fscanf(initfp,"%d",&areaNum);
for (int i=0;i<areaNum;i++){
Area *area = new Area();
fscanf(initfp,"%d",&area->start.x);
fscanf(initfp,"%d",&area->start.y);
fscanf(initfp,"%d",&area->end.x);
fscanf(initfp,"%d",&area->end.y);
this->areas.push_back(area);
}
}else{
this->capture = this->fromCamera();
}

cvNamedWindow( "Capture", 1 );
cvSetMouseCallback ("Capture", on_mouse);
cvNamedWindow( "Graph", 1 );
cvMoveWindow("Graph",0,0);

cvSetMouseCallback ("Capture", on_mouse);
this->fp = fopen("nyan.txt","w");
double fps = cvGetCaptureProperty(this->capture,CV_CAP_PROP_FPS);

}

void ManyAreaValue:: mainloop(void)
{
while (1) {
count++;
position++;
if(count>1200)count = 0;
for (int i=0;i<speed;i++){
this->frame = cvQueryFrame (this->capture);
}
if ( this->frame == NULL ){
cvSetCaptureProperty( this->capture, CV_CAP_PROP_POS_FRAMES, 0.0 );
this->frame = cvQueryFrame(this->capture);
continue;
}
if (this->areas.size() > 0){
this->calucurateAreaRGB(this->frame);
this->printAreaRGB();
for(int i=0;i<this->areas.size();i++)
this->drawLine(this->frame,this->areas[i]->start,this->areas[i]->end,CV_RGB (255, 0, 0),2);
}
cvShowImage ("Capture",this->frame);
ch = cvWaitKey ( 1 ); // 0 はディレイ時間 (ミリ秒単位)
if (ch == '\x1b') {
// ESC キー
break;
    }
  }
}

Camshift(物体追従)

ManyCamShiftAreaDesition.h
-------------------------------------

#pragma once
#include "cvbase.h"
#include "opencv2/video/tracking.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"

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

using namespace cv;
using namespace std;
class CamShiftResult
{
public:
int frameNum;
RotatedRect trackBox;
};
class CamShiftArea
{
public:
CamShiftArea(void);
CamShiftArea(int width,int height);
~CamShiftArea(void);
Rect selection;
bool selectObject;
int trackObject;
Mat histimg;
Mat backproj;
Mat hist;
Rect trackWindow;
Mat positionData;
Mat graph;
int beforeAreaNum;
int beforeTime;
FILE *csvFile;
vector<Point2f> points;
vector<CamShiftResult *> results;
int getTimePoint(int x,int y);
int getAreaNum(Point2f p);
void drawGraph(Mat graph,int time,int areaNum);
void drawLines(Mat image,cv::Scalar color,bool colorFlag);
void drawTarget(Mat image,cv::Scalar color,int num);
void drawArea(Mat image);
void calucurateCamShit(Mat image,int num,int nowTime,int _vmin, int _vmax ,int smin,bool backprojMode);

};
class ManyCamShiftAreaDesition:
public CVBase
{
public:
ManyCamShiftAreaDesition(void);
~ManyCamShiftAreaDesition(void);void init(void);
void mainloop(void);
void term(void);
void mouseEvent (int event, int x, int y, int flags, void *param);
void keyEvent(char c);
void drawNowPoint(Mat graph,int num);

void startCreateArea(int x, int y);
void endCreateArea(int x, int y);
void timeShift(int x, int y);
void createWork(int x,int y);

int speed;
bool paused;
int targetArea;
int waitSprrd;

vector<CamShiftArea *> areas;
CamShiftArea *tmpArea;

Mat image;
Mat positionData;
int caluculatedNum;

bool backprojMode;
bool showHist;
Point origin;
Rect selection;
int vmin;
int vmax;
int smin;
VideoCapture cap;

vector<Point2f> tmpPoints;
};




ManyCamShiftAreaDesition.cpp
---------------------------------------

#include "ManyCamShiftAreaDesition.h"

void on_mouse (int event, int x, int y, int flags, void *param = NULL);
Scalar convertNum2Scalar(int num)
{
num++;
printf("%d,%d,%d\n",((int)num%(255*255))%255, (int)((int)num%(255*255))/255, (int)num/255/255);
return Scalar(((int)num%(255*255))%255, (int)((int)num%(255*255))/255, (int)num/255/255);
}

Scalar convertSmallNum2Scalar(int num)
{
int r,g,b;
if(num == 0){
r = 255;
g = 100;
b = 100;
}else if(num == 1){
r = 255;
g = 255;
b = 100;
}else if(num == 2){
r = 255;
g = 100;
b = 255;
}else if(num == 3){
r = 100;
g = 255;
b = 100;
}else if(num == 4){
r = 100;
g = 255;
b = 255;
}else if(num == 5){
r = 100;
g = 100;
b = 255;
}else{
r = 255;
g = 255;
b = 255;
}
return Scalar(r,g,b);
}

Scalar convertMidiumNum2Scalar(int num)
{
int r,g,b;
num %= (255*6);
if(num <255){
r = 255;
g = num;
b = 0;
}else if(num < 255 * 2){
r = 255-(num - 255 * 1);
g = 255;
b = 0;
}else if(num < 255 *3){
r = 0;
g = 255;
b = num - 255 * 2;
}else if(num < 255*4){
r = 0;
g = 255-(num - 255 * 3);
b = 255;
}else if(num < 255*5){
r = num - 255 * 4;
g = 0;
b = 255;
}else if(num < 255 * 6){
r = 255;
g = 0;
b = 255-(num - 255 * 5);
}
return Scalar(r,g,b);
}

int convertScalar2Num(int r,int g,int b)
{
return b * 255 * 255 + g * 255 + r-1;
}

CamShiftArea::CamShiftArea(void)
{
histimg = Mat::zeros(200, 320, CV_8UC3);
selectObject = false;
trackObject = 0;
}

CamShiftArea::CamShiftArea(int width,int height)
{
histimg = Mat::zeros(200, 320, CV_8UC3);
positionData = Mat::zeros(width, height, CV_8UC3);
selectObject = false;
trackObject = 0;
positionData = Mat::zeros(width, height, CV_8UC3);
beforeAreaNum = -1;
beforeTime = 0;

graph =  Mat::zeros( 10*10*5,1200, CV_8UC3);
}

CamShiftArea::~CamShiftArea(void)
{
}

void CamShiftArea::calucurateCamShit(Mat image,int num,int nowTime,int _vmin, int _vmax ,int smin,bool backprojMode)
{//http://iwaki2009.blogspot.jp/2013/02/opencv_68.html
int hsize = 16;
    float hranges[] = {0,180};
    const float* phranges = hranges;

Mat hsv,mask,hue;;
cv::cvtColor(image, hsv, CV_BGR2HSV);
if( trackObject  )//&& caluculatedNum < nowNum
{
/*============2 マスク画像の作成============*/
inRange(hsv,
Scalar(0, smin, MIN(_vmin,_vmax)),
Scalar(180, 256, MAX(_vmin, _vmax)),
mask);

/*============3 RGBからHSV変換し、H画像の取得============*/
int ch[] = {0, 0};
hue.create(hsv.size(), hsv.depth());
mixChannels(&hsv, 1, &hue, 1, ch, 1);

/*============4 指定エリアのヒストグラムを計算、正規化、描画============*/
if( trackObject < 0 ){
Mat roi(hue, selection), maskroi(mask, selection);
calcHist(&roi, 1, 0, maskroi, hist, 1, &hsize, &phranges);
normalize(hist, hist, 0, 255, CV_MINMAX);

trackWindow = selection;
trackObject = 1;

histimg = Scalar::all(0);
int binW = histimg.cols / hsize;
Mat buf(1, hsize, CV_8UC3);
for( int i = 0; i < hsize; i++ ){
buf.at<Vec3b>(i) = Vec3b(saturate_cast<uchar>(i*180./hsize), 255, 255);
}
cv::cvtColor(buf, buf, CV_HSV2BGR);

for( int i = 0; i < hsize; i++ ){
int val = saturate_cast<int>(hist.at<float>(i)*histimg.rows/255);
rectangle( histimg, Point(i*binW,histimg.rows),
Point((i+1)*binW,histimg.rows - val),
Scalar(buf.at<Vec3b>(i)), -1, 8 );
}
}


/*============5 ヒストグラムを元にBackProjectionを計算============*/
calcBackProject(&hue, 1, 0, hist, backproj, &phranges);

/*============6 計算結果にマスクをかける============*/
backproj &= mask;

/*============7 CamShiftにより対象エリアの計算============*/
RotatedRect trackBox = cv::CamShift(backproj, trackWindow,
TermCriteria( CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 10, 1 ));

/*============8 次回探索枠の計算============*/
if( trackWindow.area() <= 1 ){
int cols = backproj.cols, rows = backproj.rows, r = (MIN(cols, rows) + 5)/6;
trackWindow = Rect(trackWindow.x - r, trackWindow.y - r,
trackWindow.x + r, trackWindow.y + r) &
Rect(0, 0, cols, rows);
}
if( backprojMode ){
cv::cvtColor( backproj, image, CV_GRAY2BGR );
}

/*============現在エリアの探索============*/
int areaNum=this->getAreaNum(trackBox.center);

/*============チャートの描画============*/
if (areaNum != -1)
this->drawGraph(graph,num,areaNum);

/*============エリア移動時はCSVに出力============*/
if(areaNum != beforeAreaNum){
fprintf(csvFile,"%d,%d\n",areaNum,nowTime-beforeTime);
beforeTime = nowTime;
beforeAreaNum = areaNum;
}

/*============探索結果を保存============*/
CamShiftResult *result = new CamShiftResult();
result->frameNum = num;
result->trackBox = trackBox;
this->results.push_back(result);

/*============軌跡を描画============*/
if (this->results.size() > 1){
cv::line(positionData,
this->results[this->results.size()-1]->trackBox.center,
this->results[this->results.size()-2]->trackBox.center,
convertNum2Scalar(num),8,8,0);
}
}
}

int CamShiftArea::getAreaNum(Point2f p)
{
for (int i=0;i<(int)points.size()/4;i++){
int targeti = i * 4;
int vec1[2];
vec1[0] = points[targeti+1].x -points[targeti].x;
vec1[1] = points[targeti+1].y -points[targeti].y;
int vec2[2];
vec2[0] = p.x -points[targeti].x;
vec2[1] = p.y -points[targeti].y;
if (vec1[0]*vec2[0]+vec1[1]*vec2[1] > 0.0){
targeti++;
vec1[0] = points[targeti+1].x -points[targeti].x;
vec1[1] = points[targeti+1].y -points[targeti].y;
vec2[0] = p.x -points[targeti].x;
vec2[1] = p.y -points[targeti].y;
if (vec1[0]*vec2[0]+vec1[1]*vec2[1] > 0.0){
targeti++;
vec1[0] = points[targeti+1].x -points[targeti].x;
vec1[1] = points[targeti+1].y -points[targeti].y;
vec2[0] = p.x -points[targeti].x;
vec2[1] = p.y -points[targeti].y;
if (vec1[0]*vec2[0]+vec1[1]*vec2[1] > 0.0){
targeti++;
vec1[0] = points[targeti-3].x -points[targeti].x;
vec1[1] = points[targeti-3].y -points[targeti].y;
vec2[0] = p.x -points[targeti].x;
vec2[1] = p.y -points[targeti].y;
if (vec1[0]*vec2[0]+vec1[1]*vec2[1] > 0.0){
return i;
}
}
}
}
}
return -1;

}

void CamShiftArea::drawGraph(Mat graph,int time,int areaNum)
{
cv::line(graph,cvPoint(time%1200,(int)(time/1200) *10*10+ areaNum*10),cvPoint(time%1200,(int)(time/1200) *10*10+ areaNum*10+10),convertMidiumNum2Scalar(time) , 1, CV_AA, 0);

}

void CamShiftArea::drawLines(Mat image,cv::Scalar color,bool colorFlag)
{
for (int i = 1;i < results.size();i++){
if(colorFlag){
color = convertMidiumNum2Scalar(results[i]->frameNum);
cv::line(image,results[i-1]->trackBox.center,results[i]->trackBox.center,color,1,8,0);
}else{
cv::line(image,results[i-1]->trackBox.center,results[i]->trackBox.center,color,1,8,0);
}
}


}

void CamShiftArea::drawTarget(Mat image,cv::Scalar color,int num)
{
for (int i = 0;i < results.size();i++){
if(results[i]->frameNum == num){
ellipse( image, results[i]->trackBox, color, 3, CV_AA );
}
}
return;
}

void CamShiftArea::drawArea(Mat image)
{
int areaNum = 0;
for (int i = 1;i < points.size();i++){
Scalar color = convertMidiumNum2Scalar(areaNum*50);
areaNum++;
cv::line(image,points[i-1],points[i],color,3,8,0);
i++;
if(i < points.size()){
cv::line(image,points[i-1],points[i],color,3,8,0);
i++;
}
if(i < points.size()){
cv::line(image,points[i-1],points[i],color,3,8,0);
cv::line(image,points[i-3],points[i],color,3,8,0);
i++;
}
}
}

int CamShiftArea::getTimePoint(int x,int y)
{
cv::Vec3b bgr = positionData.at<cv::Vec3b>(y,x);
printf("%d,%d,%d\n",bgr[0],bgr[1],bgr[2]);
if(bgr[0] == 0 && bgr[1] == 0 && bgr[2]==0)return -1;
int num = convertScalar2Num(bgr[0],bgr[1],bgr[2]);
return num;
}

ManyCamShiftAreaDesition::ManyCamShiftAreaDesition(void)
{
backprojMode = false;
showHist = true;
vmin = 10;
vmax = 256;
smin = 30;
caluculatedNum = -1;
targetArea = -1;
}

ManyCamShiftAreaDesition::~ManyCamShiftAreaDesition(void)
{
}

void ManyCamShiftAreaDesition::startCreateArea(int x, int y)
{
origin = Point(x,y);
tmpArea = new CamShiftArea( image.rows, image.cols);
tmpArea->selection = Rect(x,y,0,0);
}

void ManyCamShiftAreaDesition::endCreateArea(int x, int y)
{
tmpArea->selection.x = MIN(x, origin.x);
tmpArea->selection.y = MIN(y, origin.y);
tmpArea->selection.width = std::abs(x - origin.x);
tmpArea->selection.height = std::abs(y - origin.y);
tmpArea->selection &= Rect(0, 0, image.cols, image.rows);
if( tmpArea->selection.width > 0 && tmpArea->selection.height > 0 ){
tmpArea->trackObject = -1;
tmpArea->beforeTime = cap.get(CV_CAP_PROP_POS_MSEC );
char hoge[256];
sprintf(hoge,"ManChart%d.csv",areas.size());
tmpArea->csvFile = fopen(hoge,"w");
targetArea = 0;
if (areas.size() == 0){
for (int i=0;i<this->tmpPoints.size();i++){
tmpArea->points.push_back(this->tmpPoints[i]);
}
}
areas.push_back(tmpArea);
}else{
delete tmpArea;
}
}

void ManyCamShiftAreaDesition::timeShift(int x, int y)
{
if(targetArea > -1 && targetArea < areas.size()){
int num = areas[targetArea]->getTimePoint(x,y);
if (num > 0)cap.set(CV_CAP_PROP_POS_FRAMES ,(double)num);
}
}

void ManyCamShiftAreaDesition::createWork(int x,int y)
{
areas[targetArea]->points.push_back(cvPoint(x,y));
}

void ManyCamShiftAreaDesition::mouseEvent (int event, int x, int y, int flags, void *param)
{
    switch( event )
    {
case CV_EVENT_LBUTTONDOWN:
this->startCreateArea(x,y);
break;
case CV_EVENT_LBUTTONUP:
this->endCreateArea(x,y);
   break;
case CV_EVENT_RBUTTONUP:
if (flags & CV_EVENT_FLAG_ALTKEY){
this->timeShift(x,y);
}else{
this->createWork(x,y);
}
   break;
    }
}

void ManyCamShiftAreaDesition::keyEvent(char c)
{
switch(c){
case 'b':
backprojMode = !backprojMode;
break;
        case 'h':
            showHist = !showHist;
            if( !showHist )
                destroyWindow( "Histogram" );
            else
                namedWindow( "Histogram", 1 );
            break;
        case 'p':
            paused = !paused;
            break;
case 'n': //←
            targetArea--;
if (targetArea == -1){
targetArea = areas.size()-1;
}
            break;
case 'm': //⇒
            targetArea++;
if (areas.size() == targetArea){
targetArea = 0;
}
            break;
case 's':
            cv::imwrite("hoge.jpg",image);
cv::imwrite("positionData.jpg",positionData);
            break;
case 'q':
cv::imwrite("positionData.jpg",positionData);
            break;
case 'z':
areas.pop_back();
            break;
        default:
            break;
}
}

void ManyCamShiftAreaDesition::drawNowPoint(Mat graph,int time)
{
cv::line(graph,cvPoint(time%1200,(int)(time/1200) *10*10+ 0),cvPoint(time%1200,(int)(time/1200) *10*10+ 100),Scalar(255,255,255) , 1, CV_AA, 0);
}

void ManyCamShiftAreaDesition::init(void)
{
FILE *initfp;
initfp = fopen("ini/CamShift.txt", "r");
char fileName[256];
int mode;
fscanf(initfp,"%d",&mode);
if (mode == 1){
fscanf(initfp,"%s",&fileName);
fscanf(initfp,"%d",&speed);
this->cap.open(fileName);
int areaNum;
fscanf(initfp,"%d",&areaNum);
for(int i=0;i<areaNum;i++){
for(int j=0;j<4;j++){
int x,y;
fscanf(initfp,"%d",&x);
fscanf(initfp,"%d",&y);
this->tmpPoints.push_back(cvPoint(x,y));
}
}
}else{
cap.open(0);
}

cvNamedWindow( "Capture", 1 );
cvSetMouseCallback ("Capture", on_mouse);
}

void ManyCamShiftAreaDesition::mainloop(void)
{
    Rect trackWindow;
    int hsize = 16;
    float hranges[] = {0,180};
    const float* phranges = hranges;
this->waitSprrd = 10;

namedWindow( "Histogram", 0 );
    createTrackbar( "Vmin", "Capture", &vmin, 256, 0 );
    createTrackbar( "Vmax", "Capture", &vmax, 256, 0 );
    createTrackbar( "Smin", "Capture", &smin, 256, 0 );
    createTrackbar( "SkipSpeed", "Capture", &speed, 10, 0 );
createTrackbar( "WaitSpeed", "Capture", &this->waitSprrd, 50, 0 );

    Mat frame, histimg = Mat::zeros(200, 320, CV_8UC3),backproj,hist;
    paused = true;
cap >> frame;
frame.copyTo(positionData);
speed = 1;
   
for(;;)
    {
        if( !paused )
        {
cap >> frame;
for(int i=0;i<speed;i++){
cap >> frame;
}
            if( frame.empty() ){
                break;
}
        }

        frame.copyTo(image);
int nowNum = cap.get(CV_CAP_PROP_POS_FRAMES );
int nowTime = cap.get(CV_CAP_PROP_POS_MSEC );

if( !paused ){
if( caluculatedNum < nowNum){
for (int i=0;i<this->areas.size();i++){
areas[i]->calucurateCamShit(image,nowNum,nowTime,vmin,vmax,smin,backprojMode);
}
caluculatedNum = nowNum;
}
}
if( this->areas.size() > 0 ){
            paused = false;
}
       
     

for (int i=0;i<this->areas.size();i++) {
if (targetArea == i){
areas[i]->drawLines(image,convertSmallNum2Scalar(i),true);
areas[i]->drawArea(image);

Mat showGraph = areas[i]->graph.clone();
this->drawNowPoint(showGraph,nowNum);

imshow( "Graph", showGraph );
}else{
areas[i]->drawLines(image,convertSmallNum2Scalar(i),false);
}
areas[i]->drawTarget(image,convertSmallNum2Scalar(i),nowNum);

}

        imshow( "Capture", image );
        imshow( "Histogram", histimg );
if (this->waitSprrd == 0)this->waitSprrd=1;

char c = (char)waitKey(this->waitSprrd);
if( c == 27 ){
cv::imwrite("positionData.jpg",positionData);
for (int i=0;i<this->areas.size();i++) {
char hoge[256];
sprintf(hoge,"metyo%d.jpg",i);
cv::imwrite(hoge,this->areas[i]->positionData);
fclose(areas[i]->csvFile);
}
break;
}
this->keyEvent(c);
    }
}

void ManyCamShiftAreaDesition::term(void)
{
}

OpenCVプログラムベース

・リンカの入力にてheaderを設定


Main.cpp
--------------------------------------------------------
#include "CVBase.h"
#include <ctype.h>
#include <stdio.h>

CVBase *base;


/* コールバック関数 */
void on_mouse (int event, int x, int y, int flags, void *param = NULL)
{
base->mouseEvent(event,x,y,flags,param);
}
/* コールバック関数 */
void on_mouse2 (int event, int x, int y, int flags, void *param = NULL)
{
base->mouseEvent2(event,x,y,flags,param);
}

int main (int argc, char **argv)
{
int mode;
if (argc == 1){
FILE *fp;
fp = fopen("ini/mode.txt", "r");
fscanf(fp,"%d",&mode);
mode = 11;
}else if(argc == 2){
mode=atoi(argv[1]);
}
switch(mode){
case 0:
base = new CVBase();
break;
default:
base = new CVBase();
break;
}

base->init();
base->mainloop();
base->term();


  return 0;
}


OpenCVheader.h
--------------------------------------------------------
// バージョン取得
#define CV_VERSION_STR CVAUX_STR(CV_MAJOR_VERSION) CVAUX_STR(CV_MINOR_VERSION) CVAUX_STR(CV_SUBMINOR_VERSION)

// ビルドモード
#ifdef _DEBUG
#define CV_EXT_STR "d.lib"
#else
#define CV_EXT_STR ".lib"
#endif

// ライブラリのリンク(不要な物はコメントアウト)
#pragma comment(lib, "C:\\OpenCV2.4.5\\opencv\\build\\x86\\vc10\\lib\\opencv_core"            CV_VERSION_STR CV_EXT_STR)
#pragma comment(lib, "C:\\OpenCV2.4.5\\opencv\\build\\x86\\vc10\\lib\\opencv_highgui"        CV_VERSION_STR CV_EXT_STR)
#pragma comment(lib, "C:\\OpenCV2.4.5\\opencv\\build\\x86\\vc10\\lib\\opencv_imgproc"  CV_VERSION_STR CV_EXT_STR)
#pragma comment(lib, "C:\\OpenCV2.4.5\\opencv\\build\\x86\\vc10\\lib\\opencv_calib3d"  CV_VERSION_STR CV_EXT_STR)
//#pragma comment(lib, "opencv_gpu"   CV_VERSION_STR CV_EXT_STR)
#pragma comment(lib, "C:\\OpenCV2.4.5\\opencv\\build\\x86\\vc10\\lib\\opencv_video"   CV_VERSION_STR CV_EXT_STR)
#pragma comment(lib, "C:\\OpenCV2.4.5\\opencv\\build\\x86\\vc10\\lib\\opencv_objdetect"  CV_VERSION_STR CV_EXT_STR)
#pragma comment(lib, "C:\\OpenCV2.4.5\\opencv\\build\\x86\\vc10\\lib\\opencv_features2d" CV_VERSION_STR CV_EXT_STR)
//#pragma comment(lib, "opencv_flann"   CV_VERSION_STR CV_EXT_STR)
//#pragma comment(lib, "opencv_ffmpeg"  CV_VERSION_STR CV_EXT_STR)
//#pragma comment(lib, "opencv_ts"   CV_VERSION_STR CV_EXT_STR)
//#pragma comment(lib, "opencv_contrib"  CV_VERSION_STR CV_EXT_STR)
//#pragma comment(lib, "opencv_ml"   CV_VERSION_STR CV_EXT_STR)
//#pragma comment(lib, "opencv_legacy"  CV_VERSION_STR CV_EXT_STR)



CVBase.h
--------------------------------------------------------
#pragma once

#include "opencv2/opencv.hpp"
#include "OpenCVheader.h"

class CVBase
{
public:
CVBase(void);
~CVBase(void);

CvCapture *capture;
IplImage *frame;
int ch;
CvCapture *fromFile(char *FileName);
CvCapture *fromCamera(void);
virtual void init(void);
virtual void mainloop(void);
virtual void term(void);
virtual void mouseEvent (int event, int x, int y, int flags, void *param);
virtual void mouseEvent2 (int event, int x, int y, int flags, void *param);
void drawLine(IplImage *image,CvPoint pt1,CvPoint pt2,CvScalar rcolor,int width);
virtual void copyArea(IplImage *img ,IplImage *areaImg,CvPoint start,CvPoint end);

};



CVBase.cpp
--------------------------------------------------------
#include "CVBase.h"
#include <stdio.h>

void on_mouse (int event, int x, int y, int flags, void *param = NULL);

CVBase::CVBase(void)
{
}

CVBase::~CVBase(void)
{
}
void CVBase::mouseEvent (int event, int x, int y, int flags, void *param)
{
switch (event) {
case CV_EVENT_MOUSEMOVE:
break;
case CV_EVENT_LBUTTONDOWN:
break;
case CV_EVENT_LBUTTONUP:
break;
}
}
void CVBase::mouseEvent2 (int event, int x, int y, int flags, void *param)
{
switch (event) {
case CV_EVENT_MOUSEMOVE:
break;
case CV_EVENT_LBUTTONDOWN:
break;
case CV_EVENT_LBUTTONUP:
break;
}
}
void CVBase::drawLine(IplImage *image,CvPoint pt1,CvPoint pt2,CvScalar rcolor,int width)
{
//CvScalar rcolor = CV_RGB (255, 0, 0);
cvRectangle (image, pt1, pt2, rcolor, width, CV_AA, 0);
}
void CVBase::copyArea(IplImage *img ,IplImage *areaImg,CvPoint start,CvPoint end)
{
uchar p[3];
int hoge[3] ={0,0,0};
for (int y = 0; y < -end.y+start.y; y++) {
for (int x = 0; x < end.x-start.x; x++) {
int imgX = start.x + x;
int imgY = end.y + y;
p[0] = img->imageData[img->widthStep * imgY + imgX * 3];        // B
p[1] = img->imageData[img->widthStep * imgY + imgX * 3 + 1];    // G
p[2] = img->imageData[img->widthStep * imgY + imgX * 3 + 2]; // R
hoge[0]+=p[0];
hoge[1]+=p[1];
hoge[2]+=p[2];
areaImg->imageData[areaImg->widthStep * (areaImg->height-y) + x * 3] = p[0];
areaImg->imageData[areaImg->widthStep * (areaImg->height-y) + x * 3 + 1] = p[1];
areaImg->imageData[areaImg->widthStep * (areaImg->height-y) + x * 3 + 2] = p[2];
}
}
}
CvCapture *CVBase::fromFile(char *FileName)
{
return cvCaptureFromFile(FileName);//"C:\\Users\\aiko\\Documents\\Visual Studio 2010\\Projects\\OpenCVBase\\1_01_H_131129153000.avi");
}
CvCapture *CVBase::fromCamera(void)
{
return cvCreateCameraCapture (0);
}
void CVBase::init(void)
{

this->capture = cvCaptureFromFile("movie/2_03_R_131126171500.avi");//"C:\\Users\\aiko\\Documents\\Visual Studio 2010\\Projects\\OpenCVBase\\1_01_H_131129153000.avi");

cvNamedWindow( "Capture", 1 );
cvSetMouseCallback ("Capture", on_mouse);

double fps = cvGetCaptureProperty(this->capture,CV_CAP_PROP_FPS);

}
void CVBase:: mainloop(void)
{
while (1) {
this->frame = cvQueryFrame (this->capture);
if ( this->frame == NULL ){
cvSetCaptureProperty( this->capture, CV_CAP_PROP_POS_FRAMES, 0.0 );
this->frame = cvQueryFrame(this->capture);
continue;
}
cvShowImage ("Capture",this->frame);
ch = cvWaitKey ( 1 ); // 0 はディレイ時間 (ミリ秒単位)
if (ch == '\x1b') {
// ESC キー
break;
    }
  }
}
void CVBase::term(void)
{
cvReleaseCapture(& this->capture);
cvDestroyWindow("Capture");
}