2015년 12월 22일

스캐너를 이용한 레이저 가공 기법 (laser processing method by controlling galvanometers)

밤 문화를 좋아하신다면 현란한 레이져 쑈(laser show)를 생각할수도 있고, 철판을 자르거나, 반도체 칩 위에 순식간에 글자를 새기는 것을 보신적이 있나요?





이 원리는 레이저라는 매우 순도높은(?) 빛을 발생시키고, 이 빛을 반사시키는 정교한 기계장치및 제어 S/W에 의해 동작한답니다. 일명 스캐너(scanner) 혹은 갈바노메터(galvanometer or galvo) 라고 부르는 장치인데, 반사용 거울을 달고 이걸 아주 미세하고 빠르게 움직여 멀리 떨어진 곳에 그림을 그리기도 하고, 구멍을 뚫기도 하고, 용접이나  철판을 자르기도 합니다.


이번 시간에는 이 스캐너라는 H/W를 이용하는 방법을 소개시켜드리겠습니다. 준비물은 독일 스캔랩(www.scanlab.de) 혹은 XY2-100 통신방식과 호환되는 스캐너 (그림 참고)를 준비해 주시고, 이를 제어해주는 컨트롤러(여기에서는 RTC를 사용함) 도 필요하답니다. 물론 레이저 발생장치가 있으면 좋겠지만 만약 없다면 레이저 포인터라도 준비해야 최소한의 준비가 됩니다.

정교한 제어 S/W를 개발하기 위해서는 다양한 역학(dynamics)을 수식으로 계산하는등의 복잡한 사전준비가 필요하지만 이런것은 H/W가 알아서 처리해준다는 믿음을 갖고 쉬운것 부터 해보는게 좋습니다.

컴파일 가능한 개발 환경 설정은 www.scanlab.de 에서 배포하는 예제 프로그램을 참고하여 준비하여 주시고,

  1. RTC4open() 함수를 호출 : rtc4dll 이 명시적으로 load 되고 함수들의 진입주소가 설정됨)
  2. load_program_file("rtc4d2.hex") 호출 : 펌웨어가 로드됨
  3. load_correction_file("cor_1to1.ctb", 1, 1,1, 0,0,0) 호출 : 무 보정파일(1:1 보정파일) 을 로드함
  4. select_cor_table(1, 0) 호출 : 보정파일을 선택함
  5. set_start_list(1) : 명령을 넣을 버퍼 준비
  6. mark_abs(), jump_abs() 함수 : x, y 가공 좌표를 입력 (move to / line to 와 유사)
  7. set_end_of_list() : 버퍼 닫기
  8. execute_list(1) : 명령 버퍼를 모두 실행(flush)
  9. get_status() : 호출하여 명령이 실행완료될때까지 지속적인 polling 실시
  10. RTC4close() : 호출하여 자원받납 후 프로그램 종료
위의 절차가 가장 간단한 사용법이 되겠습니다. 실제 mark/jump 에 입력하는 좌표를 외부 캐드등의 벡터 데이타를 가져와 입력해주면 가공이 수행되게 됩니다. 3D 프린터등에도 사용이 가능하답니다.

자, 이제 간단한 사용법을 알았으니 좀더 볼까요? 위의 초기화 과정에서 load_correction_file 의 역할을 설명해 보도록 하겠습니다.




스캐너라는 것은 위와 같이 두개의 모터를 서로 떨어뜨려 배치해 놓고 반사거울을 각각 달아 2차원 영역에 대한 위치를 제어하는 것입니다. 그러나 위 그림에서도 볼수있듯이 반사거울의 이동(각도 변화)에 따라 두 반사거울 사이의 거리가 조금씩 변하는데 이로인해 실제 레이저의 위치는 정사각형이 아닌 왜곡(distortion)되는 문제가 있습니다. 별로 믿음이 않가지요?


또한 레이저는 아시겠지만 유도된 빛이기 때문에 볼록렌즈와 같이 집광(focusing)이 가능한 광학장치를 사용해 에너지 밀도를 높혀 가공이 가능한 빛으로 만들수있습니다. 이 또한 렌즈를 통과하기 때문에 굴절(스넬의 법칙)등이 발생하고 결국 내가 가공하고자 하는 위치가 왜곡될수 밖에 없습니다.

정리하면, 2개의 반사거울을 사용하는 스캐너의 구조상 배게모양(pillow-shaped)의 왜곡과 렌즈를 사용하여 생기는 술통 모양(barrel-shaped)의 왜곡이 겹쳐 결국 위 그림에서 오른쪽과 같이 괴이한 왜곡이 발생하게 됩니다.

이런 왜곡을 해결(혹은 보상)해 주기 위해 결국 위치보정을 해주는기능을 제공하는데, 이 파일이 바로 load_correction_file 에 의해 설정됩니다. 물론 사용자가 2차원영역에 대한 측정을 마치고 이 파일을 생성시켜야 한답니다.

* 관심있는 분들이 있으면 덧글 달아주시기 바랍니다. 좀더 세부적인 설명을 해드리겠습니다.






2015년 5월 31일

콘손 출력 문자열의 리다이렉션

새로운 모듈을 개발하다보면, 오래된(legacy) 시스템이나 모듈을 재사용해야 할 경우가 많은데, 오래된 모듈에서 나오는 최종 결과가 문자열과 같이 고정된 형태만 제공한다면, 이를 전달받아 내 마음대로 처리해야 하고자 할때, 문자열을 리다이렉션하여 처리가 가능하다.



요약하면,
1. 프로세스간 통신용 파이프(pipe)를 만들고, 자식 프로세스의 표준출력 핸들을 연결해 놓자.
2. 오랜된 모듈(.exe 등)을 새로운 자식 프로세스로 만든다. 이때 표준 출력등의 핸들을 사용할수있도록 설정해 놓자.
3. 자식 프로세스에서 발생되는 표준출력/에러는 부모프로세스의 파이프로 전달된다.

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

int _tmain(int argc, _TCHAR* argv[])

{

 ::SECURITY_ATTRIBUTES sa = { 0, };

 sa.nLength = sizeof(SECURITY_ATTRIBUTES);

 sa.bInheritHandle = true;

 sa.lpSecurityDescriptor = NULL;

 HANDLE ReadPipeHandle, WritePipeHandle;

 if (!::CreatePipe(&ReadPipeHandle, &WritePipeHandle, &sa, 0))

  return FALSE;



 ::STARTUPINFO si = { 0, };

 si.cb = sizeof(STARTUPINFO);

 si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;

 si.wShowWindow = SW_HIDE;

 si.hStdOutput = WritePipeHandle;

 si.hStdError = WritePipeHandle;



 ::PROCESS_INFORMATION pi = { 0, };



 TCHAR szCmd[MAX_PATH] = { 0, };

 _stprintf(szCmd, _T("C:\\Windows\\System32\\cmd.exe"));

 TCHAR szArgs[MAX_PATH * 2] = { 0, };

 _stprintf(szArgs, _T("C:\\Windows\\System32\\cmd.exe"));



 if (!::CreateProcess(szCmd, szArgs, NULL, NULL, true, 0, NULL, NULL, &si, &pi))

  return FALSE;



 BOOL bSuccess = FALSE;

 CHAR cData[4096] = { 0, };

 for (;;)

 {

  DWORD dwBytesRead, dwTotalBytes, dwBytesLeft;

  if (!PeekNamedPipe(ReadPipeHandle, cData, sizeof(cData), &dwBytesRead, &dwTotalBytes, &dwBytesLeft))

   return FALSE;

  if (dwBytesRead)

  {

   if (!::ReadFile(ReadPipeHandle, cData, sizeof(cData) - 1, &dwBytesRead, NULL))

    return FALSE;



   cData[dwBytesRead] = '\0';

  }

  else

  {

   if (WAIT_OBJECT_0 == WaitForSingleObject(pi.hProcess, 0))

   {

    bSuccess = TRUE;

    break;

   }

  }

 }



 ::CloseHandle(pi.hThread);

 ::CloseHandle(pi.hProcess);

 ::CloseHandle(ReadPipeHandle);

 ::CloseHandle(WritePipeHandle);



 return 0;

}



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

ps. 보통 레거시 모듈은 유니코드가 아닌 ANSI 기반인 경우가 많다. ANSI/UNICODE 여부를 알아야 한다면, ::IsTextUnicode 등의 API 가 도움이 될것이다.


2014년 10월 11일

학교에서도 SW 교육을 한다

한국도 내년 (2015년) 부터 중학교 신입생부터 SW 교육을 의무적으로 이수하고, 초등학교는 2017년, 고등학교는 2018년 부터 시작이라고 합니다. 미래에는 IT 노동자들이 더욱 필요하나 이대로라면 노동력 부족이 예상되기 때문에 북미 등지에서는 이미 추진이 되고 있었지요. 북미에서는 http://code.org 라는 비영리 단체등이 있고, 국내쪽에는 http://opentutorials.org/ 등이 보이네요.

빌 게이츠 - Hour of Code - Bill Gates explains If statements


마크 주커버그 - Hour of Code - Mark Zuckerburg teaches Repeat Loops
 

조만간 컴퓨터 선생님들은 스크래치(Scratch)란 언어를 열심히 배우게 되겠죠

2014년 7월 23일

SDL2 기반의 OPENGL 렌더링 데모 2부

앞선 글에서는 간단한 도형만을 보여주였지만 이번 예제에서는 외부에서 모델 파일을 가져와 좀더 복잡한 형상을 렌더링 해 보자.

요새 각광받은 3D프린터 들을 보면 수많은 모델들이 STL (STereoLithography) 이란 파일 포맷으로 제공되고 있다. 이번 데모에서는 이 파일 포맷을 렌더링 해보자. STL 파일 포맷에 대한 정보는  http://en.wikipedia.org/wiki/STL_(file_format) , http://www.eng.nus.edu.sg/LCEL/RP/u21/wwwroot/stl_library.htm#What 에서 참고 바라며, 이번 예제에서는 바이너리 기반의 STL 파일포맷을 대상으로 한다.

이 데모의 실제 동작 화면을 캡춰해 http://www.youtube.com/watch?v=LTGfNCY0wIA 에 올려놓았다.

자 그렇다면 실제 구현에 들어가자. 마찬가지로 App 를 상속받는다.

--------------------------ex3.h
#ifndef EX3_H
#define EX3_H
 
#include "app.h"
#include <vector>
 
class Example3 : public App
{
public:
 bool OnInit(int argc, TCHAR* argv[]);
 void OnEvent(SDL_Event* Event);
 void OnLoop();
 void OnRender();
 void OnCleanUp();
 
private:
 bool LoadSTL(TCHAR* lpszFilename);
 
#pragma pack(push, 4)
 typedef struct
 {
  float x;
  float y;
  float z;
 }VERTEX; 
 typedef struct
 {
  VERTEX normal;
  VERTEX v[3];
 }FACE;
#pragma pack(pop)
 
 std::vector<face> _faces;
 VERTEX _center;
 GLuint _listid;
 float _scale;
 
public:
 Example3();
 virtual ~Example3();
};
 
#endif
-----------------------------------------ex.cpp

#include "ex3.h"
#include "log.h"

// STL 예제 파일들은 인터넷에서 검색하여 구하도록 한다
TCHAR* gszSamples[] = {
 _T("samples\\Chest_Back.stl"),
 _T("samples\\knot.stl"),
 _T("samples\\porsche.stl"),
 _T("samples\\pump.stl"),
 _T("samples\\tire_v.stl")
};

Example3::Example3()
{
 _scale = 1.0f;
}

Example3::~Example3()
{
}

bool Example3::LoadSTL(TCHAR* lpszFilename)
{
 FILE* fp = _tfopen( lpszFilename, _T("rb"));  //lpszFilename
 if (!fp)
 {
  Log("fail to open the stl file : %s", lpszFilename);
  return false;
 }
 _faces.clear();
 glDeleteLists(_listid, 1);

 // STL 이진 파일 포맷에 맞게 얻어온다
 BYTE header[80];
 fread(header, sizeof(header), 1, fp);
 UINT32 numOfFacets=0;
 fread(&numOfFacets, sizeof(numOfFacets), 1, fp);
 Log("face count = %d", numOfFacets);
 
 FACE f;
 UINT16 attr;
 for (int i=0; i< numOfFacets; i++)
 {
  fread(&f.normal, sizeof(f.normal), 1, fp);
  fread(&f.v, sizeof(f.v), 1, fp); 
  fread(&attr, 2, 1, fp);
  _faces.push_back(f);
 }
 fclose(fp);
 float xmin, xmax;
 float ymin, ymax;
 float zmin, zmax;
 xmin = 9999; xmax = -9999;
 ymin = 9999; ymax = -9999;
 zmin = 9999; zmax = -9999;

 // 크기를 알아내에 화면 중심으로 이동시키기 위해서
 for (int i=0; i< _faces.size(); i++)
 {
  if (_faces[i].v[0].x  < xmin)
   xmin = _faces[i].v[0].x;
  if (_faces[i].v[0].x  > xmax)
   xmax = _faces[i].v[0].x;
  if (_faces[i].v[0].y  < ymin)
   ymin = _faces[i].v[0].y;
  if (_faces[i].v[0].y  > ymax)
   ymax = _faces[i].v[0].y;
  if (_faces[i].v[0].z  < zmin)
   zmin = _faces[i].v[0].z;
  if (_faces[i].v[0].z  > zmax)
   zmax = _faces[i].v[0].z;
 }
 _center.x = (xmin+xmax) / 2.0f;
 _center.y = (ymin+ymax) / 2.0f;
 _center.z = (zmin+zmax) / 2.0f;
 
 // 렌더링 속도 향상을 위해 리스트 버퍼 사용
 _listid = glGenLists( 1 );
 glNewList(_listid, GL_COMPILE );
 glBegin( GL_TRIANGLES );
 glColor3f( 0.3, 0.8, 0.1);
 for (int i=0; i< _faces.size(); i++)
 {
  glNormal3fv( (float*)&_faces[i].normal);
  glVertex3fv( (float*)&_faces[i].v[0]);
  glVertex3fv( (float*)&_faces[i].v[1]);
  glVertex3fv( (float*)&_faces[i].v[2]);
 }
 glEnd();
 glEndList();
 return true;
}

bool Example3::OnInit(int argc, TCHAR* argv[])
{

 // 조명 효과 사용
 float ambLight[] = {0.7f, 0.7f, 0.7f, 1.0f};
 float specular[] = {1.0f, 1.0f, 1.0f, 1.0f};
 float specref[] = {1.0f, 1.0f, 1.0f, 1.0f};
 float lightPos[] = {500, 500, 300, 1.0f};
 glEnable(GL_LIGHTING);
 glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambLight);
 glLightfv(GL_LIGHT0, GL_DIFFUSE, ambLight);
 glLightfv(GL_LIGHT0, GL_SPECULAR, specular);
 glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
 glEnable(GL_COLOR_MATERIAL);
 glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
 glMaterialfv(GL_FRONT, GL_SPECULAR, specref);
 glMateriali(GL_FRONT, GL_SHININESS, 128);
 glEnable(GL_LIGHT0);
 return true;
}

void Example3::OnEvent(SDL_Event* e)
{
  // q : 줌 인
  // z : 줌 아웃
  // p : 렌더링 모드 변경
  switch( e->type )
  {
  case SDL_KEYDOWN:
    if (e->key.keysym.sym == 'q')
    {
     _scale *= 1.2;
    }
    else if (e->key.keysym.sym == 'z')
    {
     _scale *= 0.8;
    }
    break;
        case SDL_KEYUP:
   if (e->key.keysym.sym == 'p')
   {
    static int mode = 0;
    glPolygonMode( GL_FRONT_AND_BACK, GL_POINT+ mode );
    mode++;
    mode= mode % 3;
   }
   else if (e->key.keysym.sym >= '1' && e->key.keysym.sym <= '5')
   {
    int n = e->key.keysym.sym - '1';
    this->LoadSTL( gszSamples[n] );
   }
   
    break;
  default:
      break;
  }
}

void Example3::OnLoop()
{}

void Example3::OnRender()
{
 glClearColor( 0.1f, 0.1f, 0.1f, 1.0f );
 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
 glLoadIdentity();
 gluLookAt(300, 300, 150, 0,0,0, 0,0,1);

 static float angle = 0;
 glRotatef( angle +=0.5, 0,0,1);

 glPushMatrix();
  glScalef(_scale, _scale, _scale);
  glTranslatef(-_center.x, -_center.y, -_center.z);
  glCallList(_listid);
 glPopMatrix();

 glBegin(GL_LINES);
  glColor3f(1, 0, 0);
  glVertex3f( 0, 0, 0 );
  glVertex3f( 500, 0, 0 );
  glColor3f(0, 1, 0);
  glVertex3f( 0, 0, 0 );
  glVertex3f( 0, 500, 0 );
  glColor3f(0, 0, 1);
  glVertex3f( 0, 0, 0 );
  glVertex3f( 0, 0, 500 );
 glEnd();
}

void Example3::OnCleanUp()
{
}

---------------------------------------------------

자 그럼 메인 함수를 보자

#include "app.h"
#include "ex3.h"
int _tmain(int argc, TCHAR* args[])
{ 
 App* app = new Example3;
 int n = app->Execute(argc, args);
 return n;  
}


각종 예제 모델 파일들(STL)은 http://www.eng.nus.edu.sg/LCEL/RP/u21/wwwroot/stl_library.htm#Download 에서 다운로드 받은 것들이다. 또한 키보드 1~5번 키를 누를때 마다 모델파일을 새로 로드하도록 구현되었다.

SDL2 기반의 OPENGL 렌더링 데모 1부

앞선글에서 SDL2 및 이를 쉽게 OPENGL 기반으로 응용할수 있는 개발 환경을 소개한 바 있다. App 라는 클래스를 상속받아 렌더링 부분등의 이벤트만 구현해주면 쉽게 접근이 가능하다.




위 이미지와 같이 3차원 공간에 몇개의 도형을 렌더링 하는 코드를 작성해 보도록 하자.
우선 할것은 App 를 상속받는 것이다.

---------------------------------------ex1.h

#ifndef EX1_H
#define EX1_H

#include "app.h"

class Example1 : public App
{
public:
 bool OnInit(int argc, TCHAR* argv[]);
 void OnEvent(SDL_Event* Event);
 void OnLoop();
 void OnRender();
 void OnCleanUp();

private:

public:
 Example1();
 virtual ~Example1();
};

#endif


다음으로 할것은 실제 이벤트 핸들러등을 구현하는 것이다.

--------------------------------------- ex1.cpp

#include "ex1.h"
#include "log.h"


Example1::Example1()
{}

Example1::~Example1()
{

}

bool Example1::OnInit(int argc, TCHAR* argv[])
{
 return true;
}

void Example1::OnEvent(SDL_Event* Event)
{}

void Example1::OnLoop()
{}

void Example1::OnRender()
{
    glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

    glLoadIdentity();
 gluLookAt(5,5,10, 0,0,0,0,1,0);

 static float angle =0;
 glRotatef(angle += 1, 0,1,0);

    glBegin( GL_TRIANGLES );           
   glColor3f(1, 1, 1);
      glVertex3f(  0.0f,  1.0f, 0.0f );
      glVertex3f( -1.0f, -1.0f, 0.0f );
      glVertex3f(  1.0f, -1.0f, 0.0f );
    glEnd( );                         
    
 glPushMatrix();
    glTranslatef( 3.0f, 0.0f, 0.0f );

    glBegin( GL_QUADS );               
   glColor3f(1, 1, 0);
      glVertex3f( -1.0f,  1.0f, 0.0f );
      glVertex3f(  1.0f,  1.0f, 0.0f );
      glVertex3f(  1.0f, -1.0f, 0.0f );
      glVertex3f( -1.0f, -1.0f, 0.0f );
    glEnd( );                         
    glPopMatrix();

 glBegin(GL_LINES);
   glColor4f(1, 0, 0, 1);
      glVertex3f( 0.0f, 0.0f, 0.0f );
      glVertex3f( 5.0f, 0.0f, 0.0f );

   glColor4f(0, 1, 0, 1);
      glVertex3f( 0.0f, 0.0f, 0.0f );
      glVertex3f( 0.0f, 5.0f, 0.0f );

   glColor4f(0, 0, 1, 1);
      glVertex3f( 0.0f, 0.0f, 0.0f );
      glVertex3f( 0.0f, 0.0f, 5.0f );
 glEnd();

}

void Example1::OnCleanUp()
{

}



자 모든 구현이 완료되었다. 오직 화면을 렌더링하는 이벤트(OnRender)만 구현하였으며 다른 이벤트는 모두 미 구현상태이다. 특히 OpenGL 함수들로만 구성되어 있어 SDL 등의 익숙치 않는 함수들은 전혀 포함되어 있지 않아 쉽게 응용이 가능하게 되었다.

시작점 즉 메인함수의 모습은 아래와 같다.

#include <windows.h>
#include "app.h"
#include "ex1.h"

int _tmain(int argc, TCHAR* args[])
{ 
 App* app = new Example1;
 int n = app->Execute(argc, args);
 return n;  
}

다음 글에서는 좀더 복잡한 것들을 해보자

SDL2 기반의 OPENGL 테스트 프레임워크

SDL (Simple DirectMedia Layer) 라이브러리는 수많은 게임들에 적용된 유명한 오픈소스 프로젝트 인데, 그래픽 환경을 보면 2D 기반임을 알 수 있다.


이를 OpenGL로 변경하여 손쉽게 개발환경을 구축해 보자. 참고로 버전업된 SDL2 가 최신버전이므로 이를 기반으로 OpenGL 테스트용 환경을 만들어 보자.
기본 구조는 https://github.com/MetaCipher/sdl-2.0-basics 을 참고하였으며, 입맞에 맞게 대폭 수정하였다.

SDL 이 처음이신분들은 http://lazyfoo.net/tutorials/SDL/index.php 에서 다양한 예제를 제공하고 있으니 방문 바란다.

사용된 SDL2 버전은 2.0.3 이며 OpenGL2.1 및 1024*768 해상도에서 동작한다.


1. App.h
#ifndef APP_H
#define APP_H

/*******************************************************************************

  SDL2 Demo Application

        ----------------
        | App          |
        ----------------
        | Execute      |
        | OnInit       |
        | OnEvent      |
        | OnLoop       |
        | OnRender     |
        | OnCleanUp    |
        ----------------
            /|\
             |
             |
             |
         your inherited class

  email : sepwind@gmail.com (blog : http://sepwind.blogspot.com)
  base code from : https://github.com/MetaCipher/sdl-2.0-basics (Tim Jones @ SDLTutorials.com)
  and revisied by sepwind.

*******************************************************************************/

#include "SDL.h"
#include "SDL_opengl.h"
#include <gl\gl.h>
#include <gl\glu.h>
#include <stdio.h>
#include <tchar.h>

#pragma comment(lib, "sdl2.lib")
#pragma comment(lib, "opengl32.lib")
#pragma comment(lib, "glu32.lib")


class App
{
protected:
   int _windowWidth;
   int _windowHeight;
   bool _running;
   SDL_Window* _pWindow;
   SDL_GLContext _glcontext;

private:
   bool Init();
   bool InitGL();
   void Render();
   void CleanUp();

public:
   virtual bool OnInit(int argc, TCHAR* argv[])=0;
   virtual void OnEvent(SDL_Event* Event)=0;
   virtual void OnLoop()=0;
   virtual void OnRender()=0;
   virtual void OnCleanUp()=0;

public:
   App();
   virtual ~App();
   int Execute(int argc, TCHAR* argv[]);
   int GetWindowWidth();
   int GetWindowHeight();
};

#endif


2. App.cpp


#include "app.h"
#include "log.h"

App::App()
{
   _running = true;
   _pWindow = NULL;
   _glcontext = NULL; 
   _windowWidth = 1024;
   _windowHeight = 768;
}

App::~App()
{
}

int App::GetWindowWidth()  { return _windowWidth; }
int App::GetWindowHeight() { return _windowHeight; }

bool App::Init()
{
   if(SDL_Init(SDL_INIT_VIDEO) < 0)
   {
      Log("Unable to Init SDL: %s", SDL_GetError());
      return false;
   }

   if(!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "1"))
   {
      Log("Unable to Init hinting: %s", SDL_GetError());
   }

   if((_pWindow = SDL_CreateWindow(
       "SDL2 DEMO - sepwind@gmail.com (http://sepwind.blogspot.kr)",
       SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
       _windowWidth, _windowHeight, SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL)) == NULL)
   {
      Log("Unable to create SDL Window: %s", SDL_GetError());
      return false;
   }
 
   _glcontext = SDL_GL_CreateContext(_pWindow);
   SDL_GL_SetSwapInterval(1);

   this->InitGL();
   Log("success to initialized ... ");
   return true;
}

bool App::InitGL()
{
    glShadeModel( GL_SMOOTH );
    glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
    glClearDepth( 1.0f );
    glEnable( GL_DEPTH_TEST );
    glDepthFunc( GL_LEQUAL );
    glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
  
    GLfloat ratio = ( GLfloat )_windowWidth / ( GLfloat )_windowHeight;
    glViewport( 0, 0, ( GLsizei )_windowWidth, ( GLsizei )_windowHeight );
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective( 45.0f, ratio, 0.1f, 1000.0f ); // z-near/far

    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();
    return true;
}

void App::Render()
{
   SDL_GL_MakeCurrent(_pWindow, _glcontext);
   this->OnRender();
   SDL_GL_SwapWindow(_pWindow);
}

void App::CleanUp()
{
   Log("cleaning up ... ");
   this->OnCleanUp();
   if (_glcontext)
   {
      SDL_GL_DeleteContext(_glcontext);
      _glcontext = NULL;
   }
   if(_pWindow)
   {
      SDL_DestroyWindow(_pWindow);
      _pWindow = NULL;
   }
   SDL_Quit();
}

int App::Execute(int argc, TCHAR* argv[])
{
   if(!this->Init())
   {
      Log("fail to initialize SDL2");
      return -1;
   }

   if (false == this->OnInit(argc, argv))
   {
      Log("fail to initialize OnInit");
      return -1;
   }

   SDL_Event e;
   while(_running)
   {
      while(SDL_PollEvent(&e) != 0)
      {
       this->OnEvent(&e);
       if(e.type == SDL_QUIT)
       {
          _running = false;
       }
    }
    this->OnLoop();
    this->Render();
    SDL_Delay(0);
   }

   Log("stopping ... ");
   this->CleanUp();
   return 0;
}


3. Log.h


/*
 Basic macro for logging (can be extended for other target builds; i.e, using
 NSLog for OS X / iOS). Could also be modified to log to a file instead of
 console.

  3/11/2014
    SDLTutorials.com
    Tim Jones
*/

#ifndef LOG_H
#define LOG_H

#include <stdio.h>

#if defined(DEBUG) || defined(_DEBUG)
  #define Log(...) printf(__VA_ARGS__); printf( "\n" );
#else
  #define Log(...) ;
#endif

#endif




  • 제일 처음 할것은 App 클래스를 상속받아 필요한 함수를 구현해 주어야 한다.
  • 이후 명령행 인자들과 함께 Execute() 함수를 호출하여 가동을 시작한다.
  • 가동을 위해 최초 OnInit() 이벤트가 한번 발생하고, 
  • 사용자 입력(키보드, 마우스, 조이스틱 등)이 있을때 마다 OnEvent 가 발생한다.
  • 또한 게임로직등 다양한 일처리는 OnLoop 에서 구현하고
  • 매 프레임 렌더링 코드는 OnRender 에서 구현한다.
  • 프로그램 종료시에는 OnCleanUp 에 의해 자원회수 코드를 구현한다.


다음 글에서는 이를 기반으로 렌더링 데모를 시연해 보도록 하자.


2014년 7월 16일

프로세스 공정 능력 계산

어떤 기계장치의 계측값 내지는 측정되는 데이타를 축적하여 이를 분석하여 공정능력 (cp : capability of process) 이란 값을 산출할수 있다. 이 값은 결국 불량율 즉 수율(yield)등으로 환산할수도 있다.

관련링크 :
http://en.wikipedia.org/wiki/Process_capability_index
http://www.itl.nist.gov/div898/handbook/pmc/section1/pmc16.htm

링크에는 자세한 수식이 나와있으니 이를 기반으로 계산을 하여도 된다. Cpk 가 의미하는 바를 그래프로 보면 아래와 같다.



어쨋든 이 공정능력을 계산해주는 프로그램을 만든다면 다음과 같을 것이다.



이를 구현한 클래스를 소개하는 선에서 설명을 마치고자 한다.


---------------------------------- procap.h --------------------------------------
#ifndef procapH
#define procapH

///
/// copyright to sepwind@gmail.com (http://sepwind.blogspot.com)
///

#include <windows.h>
#include <vector>


class ProcessCapabilityPimpl;
class ProcessCapability
{
public:
 int   size();
    void  clear();
    void  reserve(int count);
    void  push_back(double sample);
    double&  operator[](int index);
 double  mean();
    double  stddev();
    double  solveCp(double lower, double upper);
    double  solveCpk(double lower, double upper);

protected:
    ProcessCapabilityPimpl*  _pPimpl;

public:
 ProcessCapability();
    virtual ~ProcessCapability();
};


#endif

---------------------------------- procap.cpp------------------------------------
#include "procap.h"
#include <cassert>
#include <math.h>

///
/// copyright to sepwind@gmail.com (http://sepwind.blogspot.com)
///

class ProcessCapabilityPimpl
{
public:
 std::vector<double> samples;

    ProcessCapabilityPimpl()
    {}
    ~ProcessCapabilityPimpl()
    {}
};

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

ProcessCapability::ProcessCapability()
{
 _pPimpl = new ProcessCapabilityPimpl;
}


ProcessCapability::~ProcessCapability()
{
 delete _pPimpl;
    _pPimpl = NULL;
}

int ProcessCapability::size()
{
 return _pPimpl->samples.size();
}

void ProcessCapability::clear()
{
 _pPimpl->samples.clear();
}

void ProcessCapability::reserve(int count)
{
 _pPimpl->samples.reserve(count);
}

void ProcessCapability::push_back(double sample)
{
 _pPimpl->samples.push_back(sample);
}

double& ProcessCapability::operator[](int index)
{
 return _pPimpl->samples[index];
}

double ProcessCapability::mean()
{
 double sum(0.0);
    std::vector<double>::iterator it;
 for(it = _pPimpl->samples.begin(); it != _pPimpl->samples.end(); it++)
    {
  sum += *it;
    }

    return sum / (double)this->size();
}

double ProcessCapability::stddev()
{
 /// sigma

 double m = this->mean();
    int n = this->size();
    double sum(0.0);

    std::vector<double>::iterator it;
 for(it = _pPimpl->samples.begin(); it != _pPimpl->samples.end(); it++)
    {
     sum += pow(*it - m, 2);
    }

    return sqrt(sum / (double)n);
}

double ProcessCapability::solveCp(double lower, double upper)
{
 assert(lower < upper);

 double cp(0.0);
    cp = (upper - lower) / (6.0 * this->stddev() );
    return cp;
}

double ProcessCapability::solveCpk(double lower, double upper)
{
 assert(lower < upper);

 double cpk(0.0);
    double m = this->mean();
    double σ = this->stddev();

    cpk = std::min<double>( \
     (upper - m) / (3.0*σ),
        (m - lower) / (3.0*σ)
        );

    return cpk;
}


원리는 링크에 나온 수식을 구현하여 매우 간단하며, solve cp, solve cpk 함수의 구현부를 참고.

시리우스 라이브러리 홈페이지 오픈

현재 시리우스(Sirius) 라이브러리라는 제품을 개발하고 이를 소개하는 홈페이지를 오픈 하였습니다. 관심있는 분들의 많은 방문 요청드립니다. 앞으로 업데이트 소식및 변경사항은 스파이럴랩 홈페이지를 통해 진행할 예정입니다. 스파이럴랩 홈페이지 :  h...