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 함수의 구현부를 참고.

2014년 7월 11일

Undo / Redo 시스템 디자인

본인이 디자인하는 S/W 기능중 Undo/Redo  적용하기 위해서는 여러가지 방법이 있을 것이다. 그중 모든 행위에 대한 추적을 통해 이력을 관리하는 방법을 설명해 보자.


이러한 디자인의 원칙은 다음과 같다.
undo/redo 가 필요한 모든 행위(함수호출)를 관리하기 위해 하나의 인터페이스를 정의하고 이를 상속 구현하여 연결리스트, 스택등의 자료구조에 차곡차곡 저장해 놓는다.






1. Action 인터페이스

  모든 행위(Action)들은 이 인터페이스를 상속받아 undo / redo 동작을 각각 구현한다. undo 는 반드시 redo 가 한 행위를 반대로 돌려놓아야 한다. 예를 들어 ActionMove 의 경우 어떤 대상을 dx, dy 만큼 이동하는 행위이고 redo 에서 dx, dy 만큼을 더했다면, undo 에서는 dx, dy 만큼을 빼도록 구현한다.

2. Action 인터페이스를 상속받은 실제 액션들 ActionMove, Action,...

 Action 인터페이스를 상속받아 undo/redo 를 구현한다. 유저가 메뉴에서 복사, 붙이기 행위를 한다면 각각 복사(ActionCopy) 객체를 생성하여 ActionControl 의 execute에 전달한다. 이후 붙이기(ActionPaste) 명령을 동일하게 execute 시킨다.
결국 ActionControl.execute() 의 내부에서는 전달받은 Action 인스턴스의 redo 함수를 호출해 주는 것에 불과하다.

3. Action 들을 저장/관리 해주는 컨트롤러 ActionControl

 이 녀석이 실제 생성된 모든 액션(Action,...)들을 자료구조(연결리스트, 스택 등 컨셉에 맞도록 선정)에 지속적으로 쌓아 저장한다. 즉 execute() 호출시 undo 를 시키고 _actions 이라는 컨테이너에 이 인스턴스의 포인터를 쌓아 놓다가, 외부에서 되돌리기 기능이 필요하다면 이 _actions 컨테이너에서 가장 앞단의 Action 인스턴스를 꺼내와 undo 를 호출해 주면 되는 것이다.


위와 같이 액션의 저장과 실제 행위를 분리하여 설계하는 것이 흔한 방식이다.

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

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