'Programming'에 해당되는 글 147건

일반적으로 프로그래밍 할 때 흔히 사용하는 rand() 함수.

난수를 발생시키고 [ rand()%범위 ] 이런 형태로 범위를 지정해서 사용하곤 했다

이런 rand() 함수가 정상적인 랜덤이 아니라니... 생각해보면 당연한 얘길수도 있겠구나 싶다

rand() 함수는 0부터 RAND_MAX  사이의 값을 임의 반환하고 RAND_MAX 는 32767로 정의되어 있다.

따라서 % 연산자를 이용하여 범위를 제한하게 되면 진정한 랜덤이 되지 않는다는거.

만약 %100 으로 0~100 까지 범위를 사용한다고 하면 확률적으로 0~67까지의 숫자가 나올 확률이 

68~100 까지 의 확률보다 더 높다. 뭐 이런얘기다.

이것 말고도 여러 이유가 있겠지만 아무튼 정확한 랜덤이 아니므로 다른 난수생성기를 사용 할 필요가 있다.

내가 사용하기 시작한 것은 메르센 트위스터 라는 난수발생기이다.

프로그램에서 <random> 을 포함하면 사용 가능하다.

사용법도 rand() 에 비해 크게 어렵지 않으니 교체해서 사용하는데 큰 어려움은 없을 것 같다.

인터넷에 흔히 나오는 방법1 과 내가 사용하는 방법2 둘다 가능하니 읽기 편한대로 쓰면 될거 같다.

1. #include <random>
2.  
3. // 방법 1
4. mt19937 rEngine( (unsigned)time(NULL) );
5. uniform_int_distribution<int> dist( min, max );
6. auto rGenerator = bind( dist, rEngine );
7.  
8. int randomValue = rGenerator();
9.  
10.  
11. // 방법 2
12. mt19937 rEngine( (unsigned)time(NULL) );
13. uniform_int_distribution<int> dist( min, max );
14. int randomValue = dist( rEngine );

별도의 weight 없이 랜덤한 값을 내는 uniform distribution 외에도 사용가능한 distribution 들이 있으니

필요에 따라 사용 가능하다

• bernoulli_distribution

• geometric_distribution

• poisson_distribution

• binomial_distribution

뭐 더 있나.. 아무튼 필요에 따라 찾아 쓸 수 있다는거..

마지막으로 http://www.gamedevforever.com/114 해당글에서 rand() 와 개선된 난수생성기의 결과를 시뮬레이션 해 둔 
사진이 있어서 두 사진을 비교해 보면 성능차이가 눈에 보인다.

< rand() >

< WELL512 >

프로그램에서 영상 데이터를 unsigned char* 형의 버퍼로 가지고 이용하는 경우가 종종 있다.

이 데이터 형을 IplImage 형으로 변환하려면 아래와 같은 방법으로 변환 가능하다.

unsigned char *buffer= ...;

IplImage *img = cvCreateImage(cvSize(w,h),8,channels);
cvSetData( img , buffer , w*channels);

Mat 형식으로 변환하기 위해서는 

Mat temp = Mat( H, W, CV_8UC1 );

temp.data = buffer;

와 같은 형태로 변환 가능.

가끔 컴파일 잘 되던 프로젝트에서 

fatal error LNK1123: COFF로 변환하는 동안 오류가 발생했습니다.

이런 요상한 메세지를 띄우며 컴파일이 안 되는 경우가 있다

인터넷에서는 각종 해결방법을 소개 하긴 하지만 그런 방법으로는 해결되지 않는 경우가 더 많다.

매니패스트를 사용안한다거나 서비스팩을 설치하라던가. 이런건 운좋게 해결 될 경우도 있겠지만

해결 되지 않을 가능성이 더 크고 다음번에 또 문제가 발생 할 수 있다.

근본적인 이유는 Visual Studio 2010 과 .Net framework 4.5 버전이 맞지 않기 때문이다.

ExtensionAttribute class 가 4.0까지는 System.Core.dll에 있었는데, 4.5 부터는 mscorlib.dll로 옮겨졌다고 한다.

그래서 C++/cli 코드를 컴파일할 때, 최신버전의 mscorlib.dll을 사용하려고 하는데, 이때 4.0으로 빌드된 다른 .dll들과 충돌이 생긴다고 하네..

해결방법은

1. .Net Framework 의 버전 다운( 4.0 )

2. 컴파일러에서 강제 경로 설정.

중의 한가지를 이용하여 해결 가능하다.

제일 쉬운건 그냥 .Net Framework 4.5버전을 삭제하면 바로 문제없이 컴파일 된다.

경로 설정은 번역 해두신분이 있어 그부분만 담아 둔다.

참고

http://connect.microsoft.com/VisualStudio/feedback/details/750762/problems-building-after-installing-vs-2012-rc

다른걸 찾아보다 재미난게 보여서 기록 해 둔다.

먼저 아래의 소스코드를 보고 다시 얘기하자.

1. #include <stdio.h>
2. #include <Windows.h>
3.  
4. struct TEST1
5. {
6.         char    c;
7.         short   s;
8.         int     i;
9.         double  d;
10. };
11.  
12. struct TEST2
13. {
14.         short   s;
15.         int     i;
16.         double  d;
17.         char    c;
18. };
19.  
20. #pragma pack(1)
21. struct TEST3
22. {
23.         short   s;
24.         int     i;
25.         double  d;
26.         char    c;
27. };
28. #pragma pack()
29.  
30. void main()
31. {
32.         TEST1 T;
33.         TEST2 T2;
34.         TEST3 T3;
35.  
36.         printf( "====== T ======\n" );
37.         printf( "Sizeof(c) : %d\n", sizeof(T.c) );
38.         printf( "Sizeof(s) : %d\n", sizeof(T.s) );
39.         printf( "Sizeof(i) : %d\n", sizeof(T.i) );
40.         printf( "Sizeof(d) : %d\n", sizeof(T.d) );
41.         printf( "Sizeof(T) : %d\n", sizeof(T) );
42.  
43.         printf( "\n====== T2 ======\n" );
44.         printf( "Sizeof(c) : %d\n", sizeof(T2.c) );
45.         printf( "Sizeof(s) : %d\n", sizeof(T2.s) );
46.         printf( "Sizeof(i) : %d\n", sizeof(T2.i) );
47.         printf( "Sizeof(d) : %d\n", sizeof(T2.d) );
48.         printf( "Sizeof(T) : %d\n", sizeof(T2) );
49.  
50.         printf( "\n====== T3 ======\n" );
51.         printf( "Sizeof(c) : %d\n", sizeof(T3.c) );
52.         printf( "Sizeof(s) : %d\n", sizeof(T3.s) );
53.         printf( "Sizeof(i) : %d\n", sizeof(T3.i) );
54.         printf( "Sizeof(d) : %d\n", sizeof(T3.d) );
55.         printf( "Sizeof(T) : %d\n", sizeof(T3) );
56.  
57.         system("pause");
58. }

위의 소스코드에서 사용된 구조체 TEST1, TEST2, TEST3 의 크기는 동일할까?

세개의 구조체 모두 각각 하나씩의 char, short, int, double 형의 변수들을 멤버로 가지고 있다.

다만 선언된 순서가 다를뿐 동일하게 구성되어 있으니 저 구조체들은 동일한 크기를 가질 것이다.

일단 TEST1 구조체와 TEST2구조체의 크기를 살펴 보자

결과를 보면 구조체의 멤버변수들의 크기는 모두가 알듯이 각각 1, 2, 4, 8 byte 의 크기를 가진다.

그렇다면 구조체의 크기는 당연히 1+2+4+8 = 15byte! 가 되야하는데 아니잖아! 

이 이유는 프로젝트를 만들때 32비트용 프로그램으로 만들었기 떄문이다. 

32비트, 즉 4바이트를 기본 크기로 갖는 프로그램이라는 얘기다. 

이게 어떻게 영향을 미치는지는 아래를 보면 쉽게 이해가 된다.

먼저 TEST1 구조체를 살펴보면 

변수들을 담아야 하니 메모리공간을 할당한다.

기본크기가 4바이트니까 4바이트 짜리 공간을 만들고 그 맨앞에 제일먼저 선언된 c를 채워넣는다.

[ [c] [] [] [] ]

그다음 선언된 s 를 채워넣고..

[ [c] [s] [s] [] ]

그다음의 i를 채워넣으려는데 기본크기에서 1바이트밖에 남지않아서 4바이트 크기의 int를 담을수가 없다.

그래서 기본크기인 4바이트 짜리 공간을 하나 더 만들고 거기에 i를 채워넣는다.

[ [c] [s] [s] [-] ] [ [i] [i] [i] [i] ]

마찬가지로 뒤에 d를 넣고 나면

[ [c] [s] [s] [-] ] [ [i] [i] [i] [i] ] [ [d] [d] [d] [d] ] [ [d] [d] [d] [d] ] 

총 16바이트의 크기를 갖는 구조체가 된다.

자 그럼 이제 TEST2 구조체를 보자 

마찬가지로 기본크기 4바이트 메모리 공간을 만들고, s를 채워 넣는다.

[ [s] [s] [] [] ]

그다음 i 를 넣으려는데 2바이트 뿐이네? 그럼 어떻게?? 새로 공간을 하나 더 만들지.

[ [s] [s] [-] [-] ] [ [i] [i] [i] [i] ]

그다음 마찬가지로 c 와 d 를 넣어보면 

[ [s] [s] [-] [-] ] [ [i] [i] [i] [i] ] [ [d] [d] [d] [d] ] [ [d] [d] [d] [d] ] [ [c] [-] [-] [-] ]

20 바이트 짜리 구조체가 되어야 하는데 왜 24 바이트지.. 이건 공부해서 수정하도록..

이부분에 대한 보충설명은 아래에 덧붙임.

아직 다 이해가 되진 않지만 일단 이런식으로 메모리 할당이 되는데.

여기서 이런식으로 메모리를 낭비하고싶지 않다 할떄 쓰는게 TEST3 구조체 앞에있는 

#pragma pack(n) 전처리 문이다.

32비트 프로그램이니 기본크기가 4인데 이 기본 크기를 원하는 값으로 바꿀 수 있다.

그래서 #pragma pack(1) 이라고 선언하면 기본 크기가 1이 된다.

그래서 TEST3의 결과를 보면.

위와같이 1+2+4+8 = 15 의 크기가 됨을 알 수 있다.

하지만 이같은 경우에는 컴퓨터가 기본 메모리를 읽을떄 32비트 OS 에서는 32비트, 64비트 OS 에서는 64비트 단위로 한번에

읽어오기 떄문에 한번 읽고 뒤로 되돌아 가야 하는 경우가 매번 생기기 떄문에 속도의 저하가 발생한다.

이런 문제를 해결하기 위해 #pragma pack() 전처리문을 선언이 끝난 마지막에 한번 더 사용해 주는데 파라미터로 아무 값도

주지않고 선언하면 기본크기로 재 설정된다.

위에서 두번째 예제에서 용량이 20바이트라고 생각했는데 24바이트가 나와서 의문을 가지고 좀 더 알아 본 결과

패딩이 단순이 32비트 프로그램이라고 4바이트로 패딩되는것이 아니었다.

패딩에도 기본 규칙이 있는데 이는 아래와 같다.

여기서 두번째 규칙에 의해 예제에 나온 모든 구조체는 8바이트로 패딩이 이루어 지고 있었다.

다시 설명하자면 TEST1 구조체의 메모리 설정은 

[ [c] [s] [s] [-] ] [ [i] [i] [i] [i] ] [ [d] [d] [d] [d] ] [ [d] [d] [d] [d] ]  이런 구조가 아닌

[ [c] [s] [s] [-] [i] [i] [i] [i] ] [ [d] [d] [d] [d] [d] [d] [d] [d] ]  이런식으로 8바이트씩 들어간거 같다.

(좀더 찾아보다보니 패딩이 이루어질떄 만약 4바이트라면 css- 이런 형태가 아닌 c-ss 이런식으로 채워 넣는다는데

위예제처럼 세가지 데이터가 들어갈떈 어떻게 들어가게 되는지 궁금.. 얘도 조금 더 찾아보자 )

마찬가지로 TEST2 구조체는 

[ [s] [s] [-] [-] [i] [i] [i] [i] ] [ [d] [d] [d] [d] [d] [d] [d] [d] ] [ [c] [-] [-] [-] [-] [-] [-] [-] ] 의 형태가 되어

총 24바이트의 크기를 갖는 구조체가 되는 것이다.

==============================================================================================================

패딩규칙에 대한 설명이 잘 나와있는 곳이 있어 링크를 건다.

http://www.bloglovin.com/viewer?post=1264753195&group=0&frame_type=a&blog=9802765&frame=1&click=0&user=0

본문내용

서론 :

지금 까지 나는 byte padding이 cpu 레지스터 사이즈를 따라 일괄적으로 적용 되는 줄 알고 있었다(http://nsjokt.springnote.com/pages/4716509). 하지만 오늘 exe와 dll 사이에서 일어난 문제를 해결하며 찾아본 자료에서 byte padding은 아래의 네 가지 규칙에 따라 구조체에 따라 다르게 적용 된다는 사실을 알았다. 예를 들어 설명 하자면 지금까지 페이지 사이즈가 4byte인 어플리케이션에서는 byte padding 사이즈를 따로 지정해 주지 않는 한 1 byte 짜리 멤버 변수를 가진 구조체나 4 byte 멤버 변수를 가진 구조체의 sizeof 결과가 모두 4 byte로 같을 것이라고 생각 했으나 실제로는 각각 1 byte, 4 byte로 다르게 align 되고 있었다.

위에서 언급한 네 가지 규칙을 살펴 보자면(일단 VC 기준, gcc는 다른 옵션이 있겠지) :

1. Unless overridden with __declspec(align(#)), the alignment of a scalar structure member is the minimum of its size and the current packing.
   
2. Unless overridden with __declspec(align(#)), the alignment of a structure is the maximum of the individual alignments of its member(s).
   
3. A structure member is placed at an offset from the beginning of its parent structure which is the smallest multiple of its alignment greater than or equal to the offset of the end of the previous member.
   
4. The size of a structure is the smallest multiple of its alignment larger greater than or equal the offset of the end of its last member.

출처 : http://msdn.microsoft.com/ko-kr/library/83ythb65(v=vs.100).aspx

나름 쉽게 풀어쓴다고 썼지만 나도 알아 먹기 힘드니 예제를 통해서 알아 보도록 하자

1. Unless overridden with __declspec(align(#)), the alignment of a scalar structure member is the minimum of its size and the current packing.

"__declspec(align(#))을 오버라이드 하지 않으면, 스칼라 구조체(long, bool과 같은 일반 변수로만 이루어진 구조체)의 멤버는 변수의 사이즈와 현재 지정된 byte padding align을 따른다."

이해를 돕기 위해 아래와 같이 두 가지 타입의 구조체를 만들어 보았다 :

bool 는 1 byte, long은 4 btye, 각 구조체의 사이즈는 각각의 멤버 변수 사이즈 대로 만들어진다.

2. Unless overridden with __declspec(align(#)), the alignment of a structure is the maximum of the individual alignments of its member(s).

"__declspec(align(#))을 오버라이드 하지 않으면, 구조체는 멤버 변수중 가장 사이즈가 큰 멤버 변수의 byte padding align을 따른다."

그럼 위의 Size_1_Align 구조체에는 2 byte 변수를, Size_4_Align 구조체에는 long(4byte) 보다 작은 사이즈의 멤버 변수를 추가해 보겠다. 가장 큰 사이즈 멤버 변수의 align을 따른다고 했으므로 Size_1_Align은 2 byte align 규칙을 따를 것이고, Size_4_Align 구조체는 4 byte align 규칙을 따를 것이다 :

struct Size_1_Align
{
    bool b;  // byte padding 규칙에 따라 요 부분은 1 byte가 더 채워 질 것입니다.
    short s;
};

struct Size_4_Align
{
    long l;
    bool b;
   short s;
};

int main()
{
    std::cout << "Size_1_Align:" << sizeof(Size_1_Align) << std::endl;
    std::cout << "Size_4_Align:" << sizeof(Size_4_Align) << std::endl;
} 

output :
Size_1_Align:4
Size_4_Align:8

예상대로 각각 4 bypte 와 8 byte 가 나왔다.

3. A structure member is placed at an offset from the beginning of its parent structure which is the smallest multiple of its alignment greater than or equal to the offset of the end of the previous member.

"구조체 멤버는 부모 구조체의 byte padding align의 시작 offset에서 부터 이전 멤버 변수의 끝 offset 뒤에 자리 잡는다."

여기서 부모 구조체의 byte padding align에 대해서 잠깐 설명하자면, 부모가 4 byte padding 규칙을 가지고 실제 7 바이트 멤버만 가지고 있는 경우 7 byte 보다 큰 4 의 배수 byte offset을 시작 점으로 잡는다는 의미다. 예를 들어 :

Derived_4_Align 구조체는 Size_4_Align을 상속 받아 1 byte(char) 짜리 변수를 추가 했다. 생각해 보면 Size_4_Align의 경우 멤버 변수 나열이 4, 2, 1 byte로 나열 되었으므로 뒤에 1 바이트가 추가 되면 8 byte로 align이 될 수도 있지 않을까 생각했지만 에누리 없이 기존 8 byte에 더하여 (그리고 최대 사이즈 멤버 변수가 4 byte이므로) 12 byte 짜리 구조체가 되었다.

4. The size of a structure is the smallest multiple of its alignment larger greater than or equal the offset of the end of its last member.

"구조체의 사이즈는 가장 마지막 멤버 변수의 offset 을 기준으로 align 되는 byte의 최소 배수이며 offset과 같거나 큰 사이즈를 가진다."

말이 조금 달라지긴 했지만 위 3번에서 설명 했던 byte padding align과 같은 의미다. 결국 구조체의 사이즈는 byte padding을 통해 가장 페이징 하기 좋은 사이즈로 결정 된다는 의미다.

결국 가장 큰 멤버 변수 사이즈(8 byte)로 align 되는 구조체는 1 byte가 더 추가 되더라도 8 byte 가 증가 하며 (align 사이즈의 배수) 실제 구조체 사이즈인 9 byte 보다는 크다는 것이다.

결론 :

오늘의 핵심은 구조체의 byte padding은 모든 구조체에 일괄적용 되는 것이 아니라 규칙에 따라 각각의 최적의 align 사이즈를 가지고 있다는 것이다.

함수내에서 변경되는 값이 여러개라 리턴을 여러개 받고싶지만 리턴값은 하나밖에 받지 못한다.

이럴경우 포인터를 넘겨줘서 함수 내에서 직접 값을 받아올 수 있다.

뭐 이런경우 아니라도 다양하게 사용가능하겠지.

예제가 괜찮은게 있어서 기록 한다.

1. #include <iostream>
2. using namespace std;
3. void func1(int);
4. void func2(int *);
5. void func3(int &);
6.  
7. int main()
8. {
9.           int ins1 = 10;            // ins1 변수
10.           int *ins2 = &ins1;     // ins2 포인터 변수
11.  
12.         // void func1 (int i){
13.           func1 ( ins1 );
14.           func1 ( * ins2 );
15.  
16.         // void func2 (int *i){  // 파라미터값이 포인터이니
17.           func2 ( & ins1 );
18.           func2 ( ins2 );  // 포인터를 넘기고
19.  
20.          // void func3 (int &i){ // 파라미터에 값을 넘거야 하니
21.           func3 ( ins1 );
22.           func3 ( *ins2 ); // * 붙여 값을 넘긴다.
23.  return 0;
24. }
25.  
26. void func1 (int i)
27. {
28.           i = i * 10;
29.           cout << "func1 : "<< i << endl;
30. }
31. void func2 (int *i)
32. {
33.           int res;
34.           res= *i * 20;
35.           cout << "func2 : "<< res << endl;
36. }
37. void func3 (int &i)
38. {
39.          int res;
40.          res= i * 30;
41.          cout << "func3 : "<< res << endl;
42. }

결과

func1 : 100
func1 : 100
func2 : 200
func2 : 200
func3 : 300
func3 : 300

[출처] 파라미터값으로 포인터 넘겨 받기 part 2|작성자 바우만

난 List 를 사용할 줄 몰랐다.

주변에서 보니 List 를 사용하는 모습을 종종 보게 되는데 

잘 사용하면 편리할 것 같다.

잘 정리 해 둔 블로그가 있어 옮겨 적어놓기.

[출처] http://blog.naver.com/wono77/140041557617

1. #include <stdio.h>
2. #include <list>
3. #include <iostream>
4. #include <algorithm> //find()를 위해 필요
5.  
6. using namespace std;
7.  
8. //STL LIST 테스트를 위한 함수
9. void stl()
10. {
11.     list<char>  list1;
12.  //리스트의 반복을 가리키는 반복자 선언
13.     list<char>::iterator itor;// = list1.begin();      // 따로, 또는 이렇게 ..
14.  itor=list1.begin(); //시작을 가리키도록 한다.
15.       //이 부분이 없으면 동작안함.
16.  
17.  //-----------------------------------------
18.  //값 삽입
19.  //-----------------------------------------
20.  cout<< "--- c, b, a 값 삽입 ---" << endl;
21.     list1.push_front('c');
22.     list1.push_back('b');
23.     list1.push_back('a');
24.  //처음부터 끝까지 값 출력
25.  for(itor=list1.begin(); itor != list1.end(); itor++)
26.  {
27.   cout<< *itor << endl;
28.  }
29.  //-----------------------------------------
30.  //포인터  rewind  연습
31.  //-----------------------------------------
32.  /*
33.  itor=list1.begin(); //앞으로 다시 감기
34.  //끝에 도달할때까지 데이터 출력
35.  while(list1.end()!=itor)
36.  {
37.   cout<< *itor << endl;
38.   itor++;
39.  }
40.  */
41.  
42.  //-----------------------------------------
43.  //find -처음부터 끝까지 뒤져서 index를 던지고 있나 본다.
44.  //단 include <algorithm>
45.  //반환값은 반복자, 즉 *itor이다.
46.  //-----------------------------------------
47.     itor=find(list1.begin(), list1.end(), 'a');
48.  cout<< "----- find (a를 찾아 그 위치에 d를 삽입한다.) ----" << endl;
49.  //찾아낸 값이 있는 앞 위치에 집어 넣기
50.  //없으면 맨 뒤에 들어간다.
51.  list1.insert(itor,'d');
52.  
53.  //처음부터 끝까지 값 출력
54.  for(itor=list1.begin(); itor != list1.end(); itor++)
55.  {
56.   cout<< *itor << endl;
57.  }
58.  //-----------------------------------------
59.  //소팅
60.  //-----------------------------------------
61.  cout<< "----- sorting ----- " << endl;
62.  list1.sort();
63.  //처음부터 끝까지 값 출력
64.  for(itor=list1.begin(); itor != list1.end(); itor++)
65.  {
66.   cout<< *itor << endl;
67.  }
68.  //-----------------------------------------
69.  //b 삭제하기
70.  //-----------------------------------------
71.  cout<< "----- remove b ----- " << endl;
72.  itor=find(list1.begin(), list1.end(), 'b');
73.  list1.erase(itor);
74.  for(itor=list1.begin(); itor != list1.end(); itor++)
75.  {
76.   cout<< *itor << endl;
77.  }
78.  //-----------------------------------------
79.  //STL에서 해당 index 위치에 값을 넣는 방법
80.  //STL의 index는 맨처음이 0이다.
81.  //-----------------------------------------
82.  int i=0;
83.  int index=2;
84.  cout<< "----- 해당 index 위치(2)에 값 f 넣기  ----- " << endl;
85.  for(itor=list1.begin(); itor!= list1.end(); itor++, i++)
86.  {
87.   if(i==index) break;
88.   //cout<< *itor << endl;
89.  }
90.  //삽입
91.  list1.insert(itor,'f');
92.  //전체 출력
93.  for(itor=list1.begin(); itor != list1.end(); itor++)
94.  {
95.   cout<< *itor << endl;
96.  }
97.  //-----------------------------------------
98.  // 갯수 세기
99.  //-----------------------------------------
100.  cout<< "----- 전체 리스트의 갯수 세기   ----- " << endl;
101.  cout<< list1.size()<< endl;;
102.  //-----------------------------------------
103.  // 모두 삭제하기
104.  //-----------------------------------------
105.  
106.  cout<< "----- 리스트 모두 삭제하기   ----- " << endl;
107.  for(itor=list1.begin(); itor != list1.end();)
108.  {
109.   //if(list1.empty()) break;
110.   list1.erase(itor++); //erase의 경우 후위형 연산자로만 증가시켜야함
111.  }
112.  
113.  list1.clear();
114.  //전체 출력
115.  for(itor=list1.begin(); itor != list1.end(); itor++)
116.  {
117.   //if(list1.empty()) break;
118.   cout<< *itor << endl;
119.  }
120.  
121. }//End of stl()
122.  
123. void main(){
124.  stl();
125. }

실행결과는 다음과 같다.

이번에 사용하는 함수는 기본으로 제공되는 API 중에 

DeleteFile / MoveFile / CopyFile 이상 세가지 이다.

파일의 경로를 파라미터로 넣어주면 해당 기능이 동작하는 심플한 API 이다.

아래 예제는 해당 경로 내 모든 파일을 삭제하는 함수이다. 

DeleteFile 의경우 삭제할 파일의 경로를 파라미터로 하나 받고

MoveFile / CopyFile 의 경우에는 소스경로 복사/이동 대상경로를 파라미터로 2개 받는다.

1. void DeleteAllFiles(CString dirName)
2. {
3.         CFileFind finder;
4.        
5.         BOOL bWorking = finder.FindFile((CString)dirName + "/*.*");
6.        
7.         while(bWorking)
8.         {
9.                 bWorking = finder.FindNextFile();
10.                 if(finder.IsDots())
11.                 {
12.                         continue;
13.                 }
14.  
15.                 CString filePath = finder.GetFilePath();
16.                 DeleteFile(filePath);
17.          }
18.         finder.Close();
19. }

폴더를 이용할때 해당 폴더 내에 파일이 몇개나 들어있는지 확인 하고 싶은 경우가 종종 있다.

이때 사용 가능한 방법이다.

CFileFind 클래스를 이용하여 파일을 찾고 파일 갯수마다 갯수++ 하는 방식으로 사용한다.

CString 형태로 폴더의 경로를 입력하면 해당 폴더 내 파일 갯수를 리턴 해 준다.

1. int GetDirFilesNum(CString dirName)
2. {
3.         int count = 0;
4.         CFileFind finder;
5.        
6.         BOOL bWorking = finder.FindFile(dirName + "/*.*");
7.  
8.         while(bWorking)
9.         {
10.                 bWorking = finder.FindNextFile();
11.                 if(finder.IsDots())
12.                 {
13.                         continue;
14.                 }
15.                
16.                 count++;
17.  
18.         }
19.         finder.Close();
20.  
21.         return count;
22. }

2017. 03. 06. 추가

이런 저런 방법 써보고 제일 괜찮은 방법을 매크로로 정리

1. #include < stdio.h >
2. #include < windows.h >
3.  
4. LARGE_INTEGER Frequency;
5. LARGE_INTEGER BeginTime;
6. LARGE_INTEGER Endtime;
7. float fTime;
8. #define CHECK_TIME_START QueryPerformanceCounter( &BeginTime );
9. #define CHECK_TIME_END QueryPerformanceCounter( &Endtime );
10. #define GET_TIME(a) int64 elapsed = Endtime.QuadPart- BeginTime.QuadPart; a = float((double)elapsed / (double)Frequency.QuadPart);
11.  
12.  
13. // [How to Use]
14. CHECK_TIME_START;
15.  
16. //실행시간 확인할 코드
17.  
18. CHECK_TIME_END;
19. GET_TIME(fTime);
20.  
21. printf("Time: %f\n", fTime);

=========================이전내용===============================

이번에 알아보는 것은 Visual C++에서 시간을 측정하는 방법입니다. Visual C++에서 시간을 측정하는 방법은 여러 가지가 있는데 . ANSI C의 함수를 이용하는 방법부터 윈도우 API 함수를 이용하는 방법까지 다양합니다. 그리고, 각각의 방법을 사용하기 위해서 함수에 따라 적절히 헤더를 Include 해줘야 하기도 합니다.

다음은 DEVPIA와 MSDN 을 통해서 찾은 여러 가지 시간 측정하는 방법입니다. 여러 님들이 올리신 글들을 제가 한번 정리해 본 것이구요, 소스를 직접 테스트 해보기도 하고 수정을 하기도 했습니다. 그리고 각각의 방법들은 형태는 다르지만 모두 공통점이 있습니다. 바로 실행 시간을 측정하기 위해서 원하는 루틴의 시작점과 종료점에서 시간 측정과 관련하는 함수를 부른다는 겁니다. 그래서 그 루틴이 시작할 당시에 비해 CPU 클럭이 얼마나 지났는지를 따져서, 즉 그 시작점과 종료점의 클럭의 차이를 이용해서 실행 시간을 구합니다.

간단한 설명은 여기서 마치고, 직접 한번 살펴보세요. 그리고, 직접 한 번 돌려보시길 바랍니다.
눈으로만 읽어선 절대로 자기의 것이 될 수 없으니까요..^^;

순서..
1. clock() 함수 이용 실행시간 측정.
2. timeGetTime()함수 이용 실행시간 측정.
3. QueryPerformanceCounter()함수 이용 실행시간 측정.
4. 매크로를 이용한 실행시간 측정. [밀리세컨트(ms)단위]
5. Debugging 중에 @CLK를 이용한 실행시간 측정.
6. 프로파일 기능을 이용한 각 함수들의 실행시간 알아보기.

——————————————————————–
1. clock() 함수 이용 실행시간 측정. [초(s)단위]
——————————————————————–

어떤 작업을 수행하는데 걸리는 시간을 알고 싶은 경우는 흔하지만, 방법을 잘 몰라서 그냥 넘어가는 경우가 많습니다. 아래 소개된 방법이 가장 일반적인 방법이며 이보다 나은 방법은 아마 없다고 생각합니다. 그다지 어렵지 않으니 천천히 보세요.

컴퓨터에는 Clock Ticks라는 것이 있습니다. 그리고 운영체제에는 어떤 프로세스가 시작한지 얼마나 지났는지 알려주는 clock() 함수를 가지고 있구요. 이것을 이용하는 방법입니다.

clock_t current_tick = clock();

이 코드로 현재 프로세스가 실행한지 얼마나 지났는지를 Clock Tick단위로 알 수 있습니다. 시간을 알고 싶으시면 이 Clock Tick단위를 초단위로 변환해주면 되죠.

double current_sec = current_tick / CLOCKS_PER_SEC;

이 코드가 Tick 단위를 초단위로 환산해주는 코드입니다.
CLOCKS_PER_SEC은 time.h화일에 정의되어 있는 상수입니다.

간단히 예제를 만들어 보면,

1. #include “stdio.h”
2. #include “time.h”
3.  
4. void main()
5. {
6. clock_t before;
7. double  result;
8. before  = clock();
9.  
10. for ( int i = 0; i <32765; i++ ) printf(“%d\n”, i );
11. result = (double)(clock() – before) / CLOCKS_PER_SEC;
12.  
13. printf(“걸린시간은 %5.2f 입니다.\n”, result);
14. }

간단하게 C 스타일로 예를 들었지만, MFC환경에서도 잘 돌아갑니다.

– 김현승(Puzzle)님이 올려주신 글입니다.

——————————————————————–
2. timeGetTime() 함수 이용. [밀리세컨드(ms)단위]
——————————————————————–

제가 즐겨 쓰는 방법은 multimedia timer를 사용하는 겁니다.
함수는 timeGetTime() 이구요, 밀리세컨드(ms)단위로 측정가능합니다.
방법은 아주 간단합니다.

1. DWORD dwStartTime = timeGetTime();
2.  
3. // 처리부분
4.  
5. …
6.  
7. // 처리부분 종료
8.  
9. DWORD dwEndTime = timeGetTime();
10. printf(“%d ms”, dwEndTime-dwStartTime);

필요한 부분에 추가하시고 쓰면 됩니다.

단, 사용하기 위해서는 사용하는 파일에 Mmsystem.h 를 Include 해주고,winmm.lib 를 Project=>Setting(ALT+F7) 메뉴의 LINK 텝에서 Object/library modules: 에 추가를 해주어야 합니다..

– DEVPIA에 올리신 김영훈(zenk)님의 글입니다.

—————————————————————————–
3. QueryPerformanceCounter() 함수 이용 [ ms단위]
—————————————————————————–

다음은 QueryPerformanceFrequency() 와 QueryPerformanceCounter()를 이용한 방법입니다. 밀리 세컨드 단위로 측정 가능하구요, #include <Windows.h> 를 해주어야 합니다. 한가지 단점은 시스템에 따라 얼마나 작은 시간을 잴 수 있는지가 제한된다는 것입니다. 하지만 CPU의 속도에 의해 결정되는 것은 아니므로 조금 느린 시스템이라고 해서 걱정하실 필요는 없습니다. API 의 도움말을 보면 시스템에 따라 CPU 클럭의 레벨까지도 체크가 가능하다는군요. 사용하는 API 함수는 High Performance Timer Functions라고 불리는 QueryPerformanceFrequency() 와 QueryPerformanceCounter() 라는 두 개의 함수입니다.

앞의 놈은 자기 시스템이 최대 어느 정도까지의 timer resolution을 지원하는지를 판별하는데 쓰이구요, 뒤엣 놈은 현재의 카운터를 알아내는 데 사용됩니다. 예를 들어 앞의 함수를 콜한 후 넘겨준 파라미터 값이 10000 으로 되어 있다면 그 시스템은 10000분의 1초 (=> 1/10000) 즉 0.1밀리초까지 판별할 수 있습니다.

그리고 어떤 작업을 수행하기전에 QueryPerformanceCounter를 한번실행하고 수행후 다시 콜함으로써 각각 얻어진 카운터값의 차이를 구함으로써 수행시간을 판단할 수 있습니다

1. //멤버변수나 로컬변수로 변수지정
2.  
3. LARGE_INTEGER Frequency;
4. LARGE_INTEGER BeginTime;
5. LARGE_INTEGER Endtime;
6.  
7. //프로그램이나 클래스 시작부분에
8. QueryPerformanceFrequency( &Frequency );
9. //사용하고자 하는 부분에 다음 코딩
10. QueryPerformanceCounter( &BeginTime );
11.  
12. 처리함수();
13.  
14. QueryPerformanceCounter( &endtime );
15. int64 elapsed = Endtime.QuadPart- BeginTime.QuadPart;
16. double duringtime = (double)elapsed / (double)Frequency.QuadPart;
17.  
18. //다음은 변수를 달리 했을 때의 사용법입니다.
19.  
20. __int64 Frequency;
21. __int64 BeginTime;
22. __int64 Endtime;
23.  
24. //프로그램이나 클래스 시작부분에
25. QueryPerformanceFrequency((LARGE_INTEGER *) &Frequency );
26.  
27. //사용하고자 하는 부분에 다음 코딩
28. QueryPerformanceCounter((LARGE_INTEGER *) &BeginTime );
29.  
30. 처리함수();
31.  
32. QueryPerformanceCounter((LARGE_INTEGER *) &endtime );
33. int64 elapsed = Endtime – BeginTime;
34. double duringtime = (double)elapsed / (double)Frequency.QuadPart;

– DEVPIA에 올리신 오희백(ohpwin)님의 글을 수정한 것입니다.

————————————————————————-
4. 매크로를 이용한 실행시간 측정. [밀리세컨드(ms)단위]
————————————————————————-

1. //다음 두줄을 복사해서 쓰시면 됩니다.
2. // 이 매크로는 Win32 함수를 이용하여 nano second까지 측정할 수 있습니다.
3.  
4. #define CHECK_TIME_START  __int64 freq, start, end; if (QueryPerformanceFrequency((_LARGE_INTEGER*)&freq))  {QueryPerformanceCounter((_LARGE_INTEGER*)&start);
5.  
6. // a는 float type  milli second이고 b가 FALSE일때는 에러입니다
7.  
8. #define CHECK_TIME_END(a,b) QueryPerformanceCounter((_LARGE_INTEGER*)&end);  a=(float)((double)(end – start)/freq*1000); b=TRUE;                        } else b=FALSE;

위의 내용을 조금 바꾸면 나노까지 측정 가능하죠.. 우선은 mili가지 측정됩니다.
그리고 windows.h포함해야 합니다. 매크로로 만들어 놔서 조금은 편하답니다.
이용하는 구체적인 방법은 다음 코드를 참조하세요.

1. #include <windows.h>
2. #include <stdio.h>
3.  
4. #define CHECK_TIME_START  __int64 freq, start, end; if (QueryPerformanceFrequency((_LARGE_INTEGER*)&freq))  {QueryPerformanceCounter((_LARGE_INTEGER*)&start);
5.  
6. // a는 float type  milli second이고 b가 FALSE일때는 에러입니다
7. #define CHECK_TIME_END(a,b) QueryPerformanceCounter((_LARGE_INTEGER*)&end);  a=(float)((double)(end – start)/freq*1000); b=TRUE;                        } else b=FALSE;
8.  
9. void main()
10. {
11. float Time;
12. BOOL err;
13.  
14. CHECK_TIME_START;
15.  
16. //….측정하고자 하는 구간..예를들어..printf()같은거
17. printf(“나는 바보 입니다.”);
18.  
19. CHECK_TIME_END(Time, err);
20.  
21. if(err) printf(“printf() 걸린 시간은.. %8.6f미리세컨입니다.”,Time);
22. }

– DEVPIA에 올리신 김태연(MonoEye)님의 글을 수정한 것입니다.

——————————————————————–
5. Debugging 중에 @CLK를 이용한 실행시간 측정.
——————————————————————–

다음은 실행시간을 측정하는 간단한 Debugging Technic 입니다.

프로그램을 하다 보면, 특정한 루틴이 과연 얼마나 많은 시간을 차지하는지 알고 싶은 경우가 있습니다. 물론, 많은 경우는 아니지만, 특정한 알고리즘을 만든 경우.. 다른 알고리즘과 처리 시간을 비교해 보고 싶은 경우가 있죠. 이럴 때 시스템 시간을 구해서 비교하는 방법들을 많이 사용하는데요,

실제로는 그렇게 할 필요가 없죠.. Watch Window 에서 앞에 골뱅이(@) 붙여서 사용하는 레지스트리 값들있죠? 골뱅이 시리즈 중에 하나를 사용하시면 된답니다.

@CLK

(CLK == Clock)

위에 있는 @CLK는 말이죠. 현재 프로세스의 Clocking을 나타내줍니다. 그런데 위의 값을 사용자가 임의로 초기화 할 수 있기 때문에, 유용하게 사용할 수가 있는 것이랍니다.

자.. 예를 들어서..
A 라는 루틴이 있는데, A 가 과연 얼마나 시간이 걸리는지 알고 싶습니다.
그러면 어떻게 @CLK를 사용해야 할까요?

우선 A 에 들어가기 전에 Break Pointer를 걸어두고, @CLK를 초기화 하시면 됩니다.
그리고 A 가 끝나는 부분에 다시 Break Pointer를 걸어두시면 바뀐 @CLK 값을 확인해 보실 수 있겠죠. @CLK 값은 밀리세컨드 단위니까. @CLK/1000,d 라고 하시면 초 단위로 보실 수 있습니다.

그럼 간단한 예제를 통해서 실제 사용방법을 살펴 보고 , 마무리 하겠습니다.

1. #include “stdafx.h”
2.  
3. int main(int argc, char* argv[])
4. {
5. // Break Pointer 설치하는 방법
6. // Alt+F9 를 눌러서 Break at 란에.. 아래와 같이..
7. // {,”ClockTest.cpp”,} .23
8. // {,”ClockTest.cpp”,} .39
9. // 입력합니다.
10. // 첫번째 Break pointer
11. // 이 부분에서 ‘User Breakpointer’ 가 call 되면
12. // Watch Window 에 아래의 값을 넣습니다.
13. // —-
14. // @CLK
15. // @CLK=0
16. // —-
17. // 위에서 @CLK 는 시스템 Clocking 을 사용하겠다는 말이고,
18. // @CLK=0 는 스스템 Clocking 을 0으로 초기화 하겠다는 말입니다.
19. // 이제 이 상태에서 다시 Go 버튼을 눌러서 프로그램을 실행하면..
20. // 두번째 User Breakpointer 가 call 됩니다.
21.  
22. int i, j, k;
23. for (i = 0 ; i <1000 ; i++)
24. for (j = 0 ; j <1000 ; j++)
25. for (k = 0 ; k <1000 ; k++)
26. ;
27.  
28. // 두번째 Break Pointer
29. // 이 부분에서 ‘User Breakpointer’ 가 call 되면 Watch Window 에 있는
30. // 첫번째 @CLK 값이 초과된 시간을 보여줍니다..
31. // 물론 이 값에는 Debugging 때문에 여러가지 추가 작업들이
32. // 행해져서 정확한 프로그램 실행시간이 아니지만, 여러가지
33. //작업을 상대적으로 비교할 수는 있겠죠..
34.  
35. return 0;
36. }

– DEVPIA에 올리신 서우석(seaousak)님의 글입니다.

——————————————————————————
6. 프로파일 기능을 이용한 각 함수들의 실행시간 알아보기
——————————————————————————

프로그램을 짜면서 각 함수가 어느 정도의 시간이 걸리는 지 알아보려는 노력들을 많이 합니다. 실제 실행시간일 수도 있고 전체 프로그램에서 어느 정도의 비율로 작용하는 지 알고싶을 때도 있구요…

이 때 프로그램의 각 함수별로 실행시간과 전체에서의 비율, 호출 횟수등을 알 수 있는 방법이 있습니다. 이것은 Debug모드에서만 가능합니다…

1. Project – Settings 메뉴를 선택한다

2. Link 탭으로 간다. ‘Enable profiling’을 선택한다.

3. 그러고나면 Build 메뉴의 ‘Profile…’ 메뉴가 활성화가 된다.

4. 반드시 Rebuild 시킨후에 ‘Profile…’ 메뉴를 선택한다. 만일 그렇지 않으면 다음과 같은 메시지박스가 뜬다

5. Rebuild 시킨후 ‘Profile…’ 메뉴를 선택하면 다음과 같은 다이알로그가 뜬다

6. 여기서 ‘Function timing’을 선택하고 ‘OK’를 누르면 프로그램이 실행이 될 것이다.

7. 실행이 끝나고 나면 Output 창에 결과를 보여줄 것이다. 함수별 실행시간과 불려진 횟수 등을 확인할 수 있다.

이것을 이용하면 프로그램을 짠 후 오랜 시간이 걸리거나 짧으면서도 많이 호출되는 함수를 찾아서 프로그램을 개선시킬 수가 있다. 단, 실행되는 것이 디버그모드이고 이 때는 일반 디버그모드보다 시간이 더 걸린다는 것을 명심해야 합니다. 이 외에도 프로파일에는 여러 가지 기능이 있으니 사용해 보시기 바랍니다.

- DEVPIA에 올리신 이광진(mirjini)님의 글입니다

http://tiger5net.egloos.com/5126729

OpenCV에 포함되어 있는 기본적인 HOG 특징을 뽑아주는 함수이다.

기본 사람검출을 위한 파라미터를 이용해서 간단한 테스트만 해봤다.

나중에 이걸 쓸일이 있을지는 모르겠지만 일단 저장..

아마 다음에 hog를 쓴다면 아마 구현해서 쓰겠지... 

1. Mat img;
2.  
3. img = imread( "C:\\Users\\Administrator\\Pictures\\test.jpg" );
4.  
5. HOGDescriptor hog;
6. hog.setSVMDetector( HOGDescriptor::getDefaultPeopleDetector() );
7. vector<Rect> detected;
8.  
9. double time = double( GetTickCount() );
10.  
11. hog.detectMultiScale( img, detected, 0, Size(9,9), Size(26,20), 1.05, 2 );
12. time = double( GetTickCount() ) - time;
13.  
14. int detectedCNT = detected.size();
15.  
16. for( int i=0; i<detectedCNT; i++ )
17. {
18.         Rect people = detected[i];
19.         rectangle( img, people, Scalar(0,0,255), 2 );
20. }
21.  
22. imshow( "Result", img )

그래도 별다른 작업없이 기본 파라미터만 이용해서 

사검출 결과가 나오니 간단한 테스트용으로는 사용 할 만 하겠지?

아래사진은 작년 경주에서 찍은 사진.. 옆에 형은 초상권.. 으로인한 모자이크 처리 해드립니다.

성능은 뭐 예상대로 별로다. 어거지로 끼워 맞춘 느낌.. 

아래는 외국사이트에서 본 hog feature 시각화해서 보여주는 소스란다.

아직 확인은 안해봤지만 나중에 참고하도록 하자.

// HOGDescriptor visual_imagealizer
// adapted for arbitrary size of feature sets and training images
Mat get_hogdescriptor_visual_image(Mat& origImg,
                                   vector<float>& descriptorValues,
                                   Size winSize,
                                   Size cellSize,                                   
                                   int scaleFactor,
                                   double viz_factor)
{   
    Mat visual_image;
    resize(origImg, visual_image, Size(origImg.cols*scaleFactor, origImg.rows*scaleFactor));
 
    int gradientBinSize = 9;
    // dividing 180° into 9 bins, how large (in rad) is one bin?
    float radRangeForOneBin = 3.14/(float)gradientBinSize; 
 
    // prepare data structure: 9 orientation / gradient strenghts for each cell
	int cells_in_x_dir = winSize.width / cellSize.width;
    int cells_in_y_dir = winSize.height / cellSize.height;
    int totalnrofcells = cells_in_x_dir * cells_in_y_dir;
    float*** gradientStrengths = new float**[cells_in_y_dir];
    int** cellUpdateCounter   = new int*[cells_in_y_dir];
    for (int y=0; y<cells_in_y_dir; y++)
    {
        gradientStrengths[y] = new float*[cells_in_x_dir];
        cellUpdateCounter[y] = new int[cells_in_x_dir];
        for (int x=0; x<cells_in_x_dir; x++)
        {
            gradientStrengths[y][x] = new float[gradientBinSize];
            cellUpdateCounter[y][x] = 0;
 
            for (int bin=0; bin<gradientBinSize; bin++)
                gradientStrengths[y][x][bin] = 0.0;
        }
    }
 
    // nr of blocks = nr of cells - 1
    // since there is a new block on each cell (overlapping blocks!) but the last one
    int blocks_in_x_dir = cells_in_x_dir - 1;
    int blocks_in_y_dir = cells_in_y_dir - 1;
 
    // compute gradient strengths per cell
    int descriptorDataIdx = 0;
    int cellx = 0;
    int celly = 0;
 
    for (int blockx=0; blockx<blocks_in_x_dir; blockx++)
    {
        for (int blocky=0; blocky<blocks_in_y_dir; blocky++)            
        {
            // 4 cells per block ...
            for (int cellNr=0; cellNr<4; cellNr++)
            {
                // compute corresponding cell nr
                int cellx = blockx;
                int celly = blocky;
                if (cellNr==1) celly++;
                if (cellNr==2) cellx++;
                if (cellNr==3)
                {
                    cellx++;
                    celly++;
                }
 
                for (int bin=0; bin<gradientBinSize; bin++)
                {
                    float gradientStrength = descriptorValues[ descriptorDataIdx ];
                    descriptorDataIdx++;
 
                    gradientStrengths[celly][cellx][bin] += gradientStrength;
 
                } // for (all bins)
 
 
                // note: overlapping blocks lead to multiple updates of this sum!
                // we therefore keep track how often a cell was updated,
                // to compute average gradient strengths
                cellUpdateCounter[celly][cellx]++;
 
            } // for (all cells)
 
 
        } // for (all block x pos)
    } // for (all block y pos)
 
 
    // compute average gradient strengths
    for (int celly=0; celly<cells_in_y_dir; celly++)
    {
        for (int cellx=0; cellx<cells_in_x_dir; cellx++)
        {
 
            float NrUpdatesForThisCell = (float)cellUpdateCounter[celly][cellx];
 
            // compute average gradient strenghts for each gradient bin direction
            for (int bin=0; bin<gradientBinSize; bin++)
            {
                gradientStrengths[celly][cellx][bin] /= NrUpdatesForThisCell;
            }
        }
    }
 
 
    cout << "descriptorDataIdx = " << descriptorDataIdx << endl;
 
    // draw cells
    for (int celly=0; celly<cells_in_y_dir; celly++)
    {
        for (int cellx=0; cellx<cells_in_x_dir; cellx++)
        {
            int drawX = cellx * cellSize.width;
            int drawY = celly * cellSize.height;
 
            int mx = drawX + cellSize.width/2;
            int my = drawY + cellSize.height/2;
 
            rectangle(visual_image,
                      Point(drawX*scaleFactor,drawY*scaleFactor),
                      Point((drawX+cellSize.width)*scaleFactor,
                      (drawY+cellSize.height)*scaleFactor),
                      CV_RGB(100,100,100),
                      1);
 
            // draw in each cell all 9 gradient strengths
            for (int bin=0; bin<gradientBinSize; bin++)
            {
                float currentGradStrength = gradientStrengths[celly][cellx][bin];
 
                // no line to draw?
                if (currentGradStrength==0)
                    continue;
 
                float currRad = bin * radRangeForOneBin + radRangeForOneBin/2;
 
                float dirVecX = cos( currRad );
                float dirVecY = sin( currRad );
                float maxVecLen = cellSize.width/2;
                float scale = viz_factor; // just a visual_imagealization scale,
                                          // to see the lines better
 
                // compute line coordinates
                float x1 = mx - dirVecX * currentGradStrength * maxVecLen * scale;
                float y1 = my - dirVecY * currentGradStrength * maxVecLen * scale;
                float x2 = mx + dirVecX * currentGradStrength * maxVecLen * scale;
                float y2 = my + dirVecY * currentGradStrength * maxVecLen * scale;
 
                // draw gradient visual_imagealization
                line(visual_image,
                     Point(x1*scaleFactor,y1*scaleFactor),
                     Point(x2*scaleFactor,y2*scaleFactor),
                     CV_RGB(0,0,255),
                     1);
 
            } // for (all bins)
 
        } // for (cellx)
    } // for (celly)
 
 
    // don't forget to free memory allocated by helper data structures!
    for (int y=0; y<cells_in_y_dir; y++)
    {
      for (int x=0; x<cells_in_x_dir; x++)
      {
           delete[] gradientStrengths[y][x];            
      }
      delete[] gradientStrengths[y];
      delete[] cellUpdateCounter[y];
    }
    delete[] gradientStrengths;
    delete[] cellUpdateCounter;
 
    return visual_image;
 
}

영상 처리를 하다보면 영상 회전이 필요할 경우가 많다. 

opencv의 워프어파인 변환 함수를 이용하여 영상을 회전하는 방법이다.

특수각일경우에 대한 추가 처리를 해주면 연산 속도는 조금 더 빨라진다.

이방법이 좋은 방법은 아니지만 간단하게 회전 영상을 구할때 사용하면 괜찮다.

1. Mat RotateImage(Mat img, int angle, double x, double y)
2. {
3.         // 영상 중심기준 회전
4.         //CvPoint2D32f center = cvPoint2D32f(img.cols/2, img.rows/2);
5.        
6.         // 사용자 지정위치 (x,y) 기준 회전
7.         CvPoint2D32f center = cvPoint2D32f(x, y);
8.         CvMat* rotation = cvCreateMat(2, 3 , CV_32FC1);
9.         cv2DRotationMatrix(center, double(angle), 1.0, rotation);
10.  
11.         cvWarpAffine(&IplImage(img), &IplImage(img), rotation);
12.  
13.         cvReleaseMat(&rotation);
14.  
15.         return img;
16. }

CFileDialog 를 이용해서 ListBox 에 추가하는건 저번에 봤다.

[공부할것../C / C++ / MFC] - CFileDialog 를 이용하여 다중 파일 목록 작성

근데 이건 매번 파일을 선택해줘야 해서 귀찮다.

매번 폴더내에 존재하는 모든파일을 다 선택하고싶다던가 그런경우 사용가능한 방법

1. CString tpath = _T("폴더 경로/*.*");
2.        
3. //검색 클래스
4. CFileFind finder;
5.        
6. //CFileFind는 파일, 디렉터리가 존재하면 TRUE 를 반환함
7. BOOL bWorking = finder.FindFile(tpath); //
8.        
9. CString fileName;
10. CString DirName;
11.        
12. while (bWorking)
13. {
14.         //다음 파일 / 폴더 가 존재하면다면 TRUE 반환
15.         bWorking = finder.FindNextFile();
16.         //파일 일때
17.         if (finder.IsArchived())
18.         {
19.                 //파일의 이름
20.                 CString _fileName =  finder.GetFileName();
21.  
22.                 // 현재폴더 상위폴더 썸네일파일은 제외
23.                 if( _fileName == _T(".") || 
                        _fileName == _T("..")|| 
                        _fileName == _T("Thumbs.db") ) continue;
24.  
25.                 fileName =  finder.GetFileTitle();
26.                 m_ListBox.AddString(fileName);          
                    //읽어온 파일 이름을 리스트박스에 넣음
27.         }
28.         // 디렉터리 일때
29.         //if (finder.IsDirectory())
30.         //{
31.                 // 필요하면 여기서 처리
32.         //DirName = finder.GetFileName();
33.         //}
34. }
35. return TRUE;

// 21.06.18. 수정

// 검색할 경로 및 파일
// 특정 확장자를 갖는 파일을 검색하고 싶으면 '경로/*.jpg' 등으로 사용
CString tpath = _T("폴더 경로/*.*");
       
// 검색 클래스
CFileFind finder;
       
// CFileFind는 파일, 디렉터리가 존재하면 TRUE 를 반환함
BOOL bWorking = finder.FindFile(tpath); //
       
CString fileName;
CString DirName;
       
while (bWorking)
{
        //다음 파일 or 폴더 가 존재하면다면 TRUE 반환
        bWorking = finder.FindNextFile();
        
		// folder 일 경우는 continue
		if (finder.IsDirectory() || finder.IsDot())
			continue;
			
		// 파일 일때
        
		//파일의 이름
		CString _fileName =  finder.GetFileName();

		// 현재폴더 상위폴더 썸네일파일은 제외
		if(_fileName == _T("Thumbs.db") ) continue;

		fileName =  finder.GetFileTitle();
		m_ListBox.AddString(fileName);          
		//읽어온 파일 이름을 리스트박스에 넣음
}

return TRUE;

CFileDialog 를 이용하여 파일의 확장자를 제외한 파일명만 가져오는 방법.

다양한 방법으로 수정 가능.

1.         CString str = _T("All Files(*.*)|*.*|");        // 선택할 파일 종류
2.         CString File, filem, strre;
3.         CString strFileList;
4.  
5.         CFileDialog dlg(TRUE, NULL, NULL, OFN_ALLOWMULTISELECT, str, this);
6.  
7.         const int c_cMaxFiles = 20000 /*선택할 파일 숫자*/ ;     
                                   // 메모리 부족현상으로 확장 안해주면 몇개 못씀
8.         const int c_cbBuffSize = (c_cMaxFiles * (MAX_PATH + 1)) + 1;
9.         dlg.GetOFN().lpstrFile = strFileList.GetBuffer(c_cbBuffSize);
10.         dlg.GetOFN().nMaxFile = c_cbBuffSize;
11.  
12.         if( dlg.DoModal() == IDOK)
13.         {
14.                 for(POSITION pos=dlg.GetStartPosition(); pos != NULL;)
15.                 {
16.                         // 전체삭제는 ResetContent
17.                         File = dlg.GetNextPathName(pos);
18.  
19.                         filem = File.Right( File.GetLength()-File.ReverseFind( _T('\\') )-1 );
20.                         // 경로를 제외한 파일명       
21.                        
22.                         filem = filem.Left( filem.GetLength() - 4 );
23.                         // 확장자 제거 ( ex - .jpg )
24.  
25.                         m_ListBox.AddString( filem );
26.                 }
27.  
28.  
29.         }
30.  
31.         m_nFileCnt = m_ListBox.GetCount();
32.         strre.Format( _T("%dea load"), m_nFileCnt );
33.         AfxMessageBox( strre );

폴더브라우저를 띄워 선택된 폴더의 절대경로를 반환 받는 방법.

1. 
   
2. 
   
3.         ITEMIDLIST  *pidlBrowse;
4.         TCHAR        pszPathname[MAX_PATH];
5.         BROWSEINFO  BrInfo;
6.  
7.         BrInfo.hwndOwner = GetSafeHwnd();
8.         BrInfo.pidlRoot = NULL;
9.         memset( &BrInfo, 0, sizeof(BrInfo) );
10.  
11.         BrInfo.pszDisplayName = (LPWSTR)pszPathname;
12.  
13.         BrInfo.lpszTitle = L"폴더를 선택해 주십시오.";
14.         BrInfo.ulFlags = BIF_RETURNONLYFSDIRS;
15.  
16.         // 다이얼로그 띄우기
17.         pidlBrowse = SHBrowseForFolder(&BrInfo);
18.  
19.         if( pidlBrowse != NULL)
20.         {
21.                 // 선택한 폴더경로를 얻어옴
22.                 BOOL bSuccess = ::SHGetPathFromIDListW(pidlBrowse, pszPathname);
23.  
24.                 if ( bSuccess )
25.                 {
26.                         m_SelectedFolder = pszPathname;   //<-- 여기서 값을 입력
27.                         UpdateData(FALSE);
28.                 }
29.                 else
30.                 {
31.                         MessageBox(L"잘못된 폴더명입니다.", L"", MB_OKCANCEL|MB_ICONASTERISK );
32.                 }
33.         }

프로그래밍의 기초가 되는 함수를 작성하는 방법이다.

matlab의 함수나 프로그램들은 전부다 mfile 이란 것을 이용하여 작성되고 불려져서 사용된다.

새로운 mfile을 만들기 위해 좌측 상단의 New Script 버튼을 누르면 새로운 스크립트를 작성할 수 있는

빈 창이 뜬다.

이제부터 함수나 프로그램의 flow는 이 스크립트 창에서 작성되고 저장되어 진다.

워낙 간단한 기초만 설명하고 있어서 위의 사진 한장으로 모든것이 이해 되겠지만 살짝 집고 가자.

matlab 에서 함수의 선언은 아래와 같은 형태로 한다.

function [출력변수] = 함수이름(입력변수)

주의할점은 출력변수는 대괄호사이에 작성하고 입력변수는 소괄호 사이에 작성한다는 점이다.

함수선언 위에 삽입되는 annotation은 help명령어로 해당 함수를 불렀을때 출력되는 

해당 함수에 대한 요약문이다.

이 글을 작성하다 새로 알게된 사실인데 함수선언 위에 설명문이 여러 문단으로 작성 될 경우

가장 첫번째 문단만이 출력된다.

함수의 내용은 각자 필요에 따라 작성하되 내부에서 입력변수 를 이용하여 출력변수에 대입만 해주면 된다.

위에서는 간단하게 숫자 두개를 입력받아서 더한 결과를 출력해 주는 함수를 작성하였다.

입력값에 대한 예외처리는 생략하기로 한다.

함수를 다 작성한후 저장을 누르면 파일명은 함수명이 Default로 설정 된다.

이렇게 작성된 함수는 다른 mfile 이나 Command Window 에서 사용이 가능하다 .

사용법은 C 에서 사용하던것과 동일하다.

A 와 B 에 각각 3과 4를 입력받아 함수에 대입하고 결과값으로 7을 return 받은 모습을 확인할 수 있다.

Matlab을 영상처리에 이용하려고 시작했는데 영상처리에 쓸수 있는 Function이 뭐가 있는지조차 잘 모르겠다.

하나씩 찾아가면서 여기에 추가 해놔야지..

OpenCV 같은경우는 정보가 많은데 내가 못찾는건지 영상처리를 위한 Matlab 함수는 정리된걸 못찾겠다.

알고리즘 검증용으로 배우려는 Matlab인데 이걸 다 구현하고 있을순 없고 

찾는대로 추가하면서 나중에 찾아 써야겠다.

==========================================================================================================

영상 읽기 쓰기

imread( '파일명' )                            // 이미지 파일을 읽는다.

imwrite( image변수, '저장명' )           // 이미지 파일을 저장한다.

영상 보기 

imshow( image변수 )                        // image변수에 저장된 영상을 보여준다.

픽셀 접근하기

image변수( j,i )                                // j 번째행 i 번째열 원소에 접근한다. 이값을 받을수도 여기에 써넣을수도 있다.

영상 전체 변환

image변수 + constant                        // 전체 픽셀을 constant 만킄 더하여 변화시킨다.

image변수 * constant                        // 전체 픽셀을 constant 만큼 곱하여 변화시킨다.

double ( image변수 )                        // 자료형을 double 로 변환한다. 이는 다른 함수들이 파라미터로 double 을 

         쓰는경우가 많기 때문에 변환..

uint8( image변수 )                            // 자료형을 8비트 정수형으로 변환 C에서의 unsigned char 라고 생각하면 됨

rgb2gray( image변수 )                       // rgb 영상을 gray 영상으로 변환

rgb2hsv( image변수 )                        // rgb 영상을 hsv 영상으로 변환 - 역변환 가능

rgb2ntsc( image변수 )                       // rgb 영상을 yiq 영상으로 변환 - 역변환 가능

rgb2ycbcr( image변수 )                     // rgb 영상을 ycbcr 영상으로 변환 - 역변환 가능

mat2gray( matrix )                             // matrix 를 gray 영상으로 변환한다. 정확한 값을 얻기위해 사용

히스토그램 관련

imhist( image변수 )                            // histogram 을 생성

histeq( image변수 )                            // histogram equalization 연산을 수행한다.

이진화 관련

graythresh( image변수 )                    // Otsu's Binarization 연산을 수행한다.

Edge Detection 관련

edge( image변수, option )                 // Edge를 검출한다. 

Option 에 사용 가능한 것들은 아래와 같다.

'sobel' / 'prewitt' / 'roberts' / 'log' / 'zerocross' / 'canny'

선형공간 필터링 관련

fspecial( 'type', [parameters] )           // convolution 연산을 수행하기 위한 마스크를 생성한다. 

     type 의 종류는 아래와  같다

'average'   : 평균값 마스크 생성

'disk'        : 원형 평균 필터 마스크 생성

'gaussian' : 가우시안 저주파필터 마스크 생성

'laplacian' : 라플라시안 마스크 생성

'log'         : LoG를 위한 마스크 생성

'motion'    : 카메라가 선형으로 흔들린효과를 주는 마스크 생성

'prewitt'    : 프리윗 엣지 마스크 생성

'sobel'     : 소벨 엣지 마스크 생성

'unsharp' : 언샤프닝 마스크 생성

imfilter( image변수, mask, option )     // 마스크를 이용하여 영상에 convolution 연산을 수행한다.

비선형공간 필터링 관련

ordfilt2( image변수, index, size )        // size ( ex- 3x3 ) 안 값중 index 번째 번 값으로 채움

ex) ordfilt2( img, 5, ones(3,3) )  ==> median filtering

근데 얘는 아직 잘 이해가 안된다..

잡음 생성 관련

imnoise( image변수, 'type' )              // 영상에 잡음을 생성한다 사용되는 타입은 아래와 같다

   'gaussian' / 'localvar' / 'poisson' / 'salt & pepper' / 'speckle'

모폴로지 관련

imerode( image변수, size )               // 침식 연산을 수행한다. size 대신 strel 함수로 생성된 값이 들어가기도 한다.

imdilate( image변수, size )               // 팽창 연산을 수행한다.

imopen( image변수, size )               // 열림 연산을 수행한다.

imclose( image변수, size )              // 닫힘 연산을 수행한다.

기하학 변환 관련

imresize( image변수, scale, 'interp' )            // 영상 크기를 변환한다. interpolation option은 다음과 같다

 'nearest' / 'bilinear' / 'bicubic'

imrotate( image변수, angle, 'interp', box )      // 영상을 회전 시킨다. box는 회전후 영상 전체를 표시할지 원영상 

  사이즈에 맞춰서 자를지를 결정하는 옵션이다.

==================================================================================================

이거 말고도 함수들은 무진장 많은데 아직 모르는것들은 안썼다.

help help 를 입력해보면 맨밑에  Reference page in Help browser 가 보인다

아래에 Doc Help 를 누르면 브라우저가 뜨는데 여기서 왠만큼 찾아 볼 수 있다.

영상 처리 관련된 함수들은 Image Processing Toolbox - Function 에서 찾아 볼 수 있으니 필요한건 여기서 찾아보는걸로... 

MATLAB의 일반적인 명령어

-도움말/정보 취득 함수

help 온라인 도움말

  look for 중심어(keyword) 탐색

  what 디렉토리에 대한 파일의 목록

  which 파일의 디렉토리 위치

 info MATLAB과 MathWorks사에 대한 정보

  type M-파일의 내용 출력

  version MATLAB 버전

-MATLAB의 작업장 관리함수

  save 작업장 변수를 파일로 저장

 load 파일에서 작업장으로 변수를 복원

  who 작업장변수의 목록

  whos 작업장변수의 목록(변수 크기 및 종류 포함)

  clear 메모리에서 변수와 함수를 제거

  inmem 메모리에 탑재된 함수의 목록

  pack  조각난 메모리를복원

 quit MATLAB 종료

  exit MATLAB 종료

-MATLAB의 파일 및 운영체제 관리 함수

  cd 현재 디렉토리의 변경/출력

  pwd 현재 디렉토리의 출력

  delete 파일의삭제

  dir 디렉토리에 대한 파일의 목록

  diary MATLAB의 작업내용을 텍스트 파일로 저장

  dos 운영체제의 명령어 실행

  !(느낌표) 운영체제의 명령어 실행(Shell escape)

-MATLAB의 명령창 관리함수

  clc MATLAB 명령창의 청소

  home MATLAB 명령창의 커서를 왼쪽 위로 이동

  format 데이터 출력의 형식지정

  echo M-파일에서 명령어를 반복

  more 출력메시지를 명령창의 크기로 제약

MATLAB의 연산자와 기호

-행렬함수 (연산자)

  -요소함수(연산자)

   plus(+) 덧셈

   minus(-) 뺄셈

   mtime(*) 곱셈

   mrdivide(/) 오른쪽 나눗셈

   mldivide(\) 왼쪽 나눗셈

   mpower(^) 승수

   uplus(+) 양의 부호

   uminus(-) 음의 부호

   plus(.+) 덧셈

   minus(.-) 뺄셈

   mtime(.*) 곱셈

   rdivide(./) 오른쪽 나눗셈

   ldivide(.\) 왼쪽 나눗셈

   power(.^) 승수

   uplus(+) 양의 부호

   uminus(-) 음의 부호

-관계함수(연산자)

  -논리함수(연산자)

  lt(<) 보다 작다

   le(<=) 작거나 같다

   gt(>) 보다 크다

   ge(>=) 크거나 같다

   eq (==) 똑같다

   ne(~=) 같지 않다

   and(&) 논리곱

   or(|) 논리합

   not(~) 부정

   xor 독점합(exculsive)

-MATLAB의 특수문자

   () 우선순위/인수포함자

   {} 이종결합 연산자/세포체

   [] 동종결합연산자

   : 범위지정자

   ; 출력억제/열(row)구분자

   % 주석기호

   . 소수점/구조체필드 참조자

   ! 운영체제의 명령어 호출자

   ‘ 전치/문자열 연산자

   , 첨자분리/행(column)구분자

   = 할당기호

   ··· 앞줄과 이어쓰기 표시자

-M-파일의 디버깅

  debug 디버깅 명령어의 목록

  dbstop 실행대기점 지정

  dbstep 실행 재개

  dbcont 질행 재개

  dbclear 실행 대기점 해제

  dbstatus 실행 대기점 목록

  dbstack 함수호출스택 목록

  dbdown 작업장의 이동

  dbup 작업장의 이동

  dbtype M-파일의 내용

  dbquit  디버깅 마치기

MATLAB의 프로그래밍 관련함수

-M-파일의 생성 및 정보취득 함수

   function 세로운 함수를 생성

   global 전역변수로 지정

   mfrlename 현재 실행되는 M-파일의 이름 취득

   isglobal 전역변수 확인  함수

   exist 식별자의 존재형태 확인 함수

-M-파일의 인수 취득 함수

   nargchk 인수의 개수 검사함수

   nargin 입력인수의 개수 반환함수

   nargout 출력인수의 개수 반환함수

   varargin 가변 입력인수

   varargout 가변 출력인수

   inputname 실인수의 이름 반환함수

- M-파일에서의 메시지 출력 함수

   warning 경고메세지 출력

   error 에러메시지 출력및 실행중단

   lasterr 가장최근의 에러메세지 반환

   disp 메시지/데이터 출력

   sprintf 형식있는 데이터를 메시지로 변환

   fprintf 형식있는 메시지 출력

-M-파일의 작성언어

   if/else/elseif  if조건문

   for  for반복문(반복횟수 기결정)

   while while 반복문(반복횟수 미결정)

   end 조건문 및 반복문의 끝마침

   switch  switch조건문

   case switch의 case문

   otherwise switch의 디폴트 case문

   break 루프의 탈출

   return 호출함수로의 복귀

-M-파일에서의 문자열 평가함수

   eval MATLAB 표현식을 갖는 문자열의 평가

   feval 문자열로 표현된 함수의 평가

   evalin 문자열을 호출작업장에서 평가

   assignin 문자열을 호출작업장에 할당

-M-파일의 대화식 작성함수

   input 사용자 입력용 프롬프트

   keyboard M-파일의 키보드 모드로의 실행

   puase 사용자의 입력 대기함수

-M-파일 함수

disp(ans)  변수이름을 확인하지 않고 결과를 출력

echo      스크립트 파일 명령들을 명령창에 출력할 것인지를 제어

input      입력을 위한 프롬프트

keyboard 일시적으로 키보드로 제어 (빠져나가려면 return을 입력)

pause     어떤 키보드를 누를 때까지 대기

pause(n)   n초 동안 대기

waitforbuttonpress  키보드나 마우스를 누를 때까지 대기

MATLAB 행렬(데이터)의 기본적인 조작함수

-MATLAB 행렬(데이터)의 생성함수

   ones 요소가 모두 1인 행렬

   zeros 요소가 모두 0인 행렬

   eye 단위행렬

   diag 대각행렬

   cat 행렬의 연결함수

   repmat 행렬의 복제함수

   rand 0에서 1사이의 난수행렬

   randn 평균이 0이고 분산이 1인 정규분포행렬

   magic 열,행 및대각선의 합이 모두 같은 행렬

   meshgrid 3차원 그래프를 위한 영역 변환함수

   linspace 선형간격으로 데이터 생성

   logspace 로그간격으로 데이터 생성

-MATLAB행렬(데이터)의 정보취득 함수

   size  행렬의 크기반환

   length 행렬의 크기에서 가장 큰 값을 반환

   ndims  행렬의 차원수를 반환

   isempty 공행렬 검사

   isfinite 행렬의 유한요소 검사

   isnan 행렬의 NaN 검사

   isinf 행렬의 inf 검사

   isequal 행렬의 등가 검사

   any 행렬의 모든 요소가 0일 때에만 거짓(0)을 반환

   all 행렬의 모든 요소가 1일 때에만 참(1)을 반환

MATLAB 행렬(데이터)의 조작함수

find   입력조건에 맞는 첨자의 변환

end    마지막 첨자

reshape행렬의 크기 변경함수

diag   행렬의 대각선 요소 추출함수

rot90  행렬의 90° 회전

fliplr   행렬의 행을 위쪽에서 오른쪽으로 자리바꿈

flipud  행렬의 열을 위쪽에서 아래쪽으로 자리바꿈

-MATLAB의 내정(built-in)변수 및 상수

ans    명령창에 최근에 출력된 답을 저장

eps    부동소숫점의 상대정확도

flops  부동소숫점에서의 계산 횟수

realmax부동소숫점에서 가장 큰 값

realmin 부동소숫점에서 가장 작은 값

pi      원주율(3.1415926535897)

i, j    복소수의 허수단위(imag(log(-1)))

inf     무한대

NaN   부정 혹은 불능 값

clock  현재의 날짜와 시간

date   현재의 날짜

tic, toc 스톱시계(stop watch)의 시작과 끝

MATLAB의 기본적인 수학함수

-MATLAB의 기본적인 수학 변환함수

fix     소숫점이하 무시

ceil    소숫점이하 올림

floor   소숫점이하 내림

round 반올림

rem   나머지

abs    절대값

sqrt   제곱근

exp    지수   

log    자연로그       

log 10 상용로그

-삼각 및 쌍곡선 함수

sin    사인

cos    코사인

tan    탄젠트

sec    사인의 역수

csc    코사인의 역수

cot    탄젠트의 역수

sinh   사인쌍곡선

cosh   코사인쌍곡선

tanh   탄젠트쌍곡선

sech   사인쌍곡선역수

csch   코사인쌍곡선역수

coth   탄젠트쌍곡선역수

-역삼각 및 역 쌍곡선 함수

asin   역사인

acos   역코사인

atan, atan역탄젠트

asex   역사인의 역수

acsc   역코사인의 역수

acot   역탄젠트의 역수

asinh  역사인쌍곡선

acosh 역코사인 쌍곡선

atanh  역탄젠트 쌍곡선

asech 역사인쌍곡선 역수

acsch  역코사인쌍곡선 역수

acoth  역탄젠트쌍곡선 역수