알콩달콩 곰돌이네~

홈페이지에 누가 얼마나 왔다 갔는지 궁금하세요 ?
누가 어떤 경로로 왔는지 궁금하시죠 ?
Google 의 Analytics 는 최고의 홈페이지 방문 통계툴이다.


항상 느끼는 건데 구글은 정말 대단한 회사이다.
모든 회사들이 포탈이다 뭐다 하면서 복잡한 플래쉬에 이런 저런 정보로 도배를 했을 때에도 구글은 심플(simple)함 그 자체이다.



검색만 하는 사람은 딱 좋은 환경이다. 결과도 잘나오고 지저분하지 않고 빠르게 뜨기 때문에 구글은 최고의 검색엔진이다.

결국 구글은 포탈로 돈을 안벌고 검색엔진만으로 엄청난 광고 수입을 올리고 있다. 부럽다. 나도 이런거나 만들껄...

구글이 검색이 잘 되는 것은 홈페이지 정보를 정확하게 얻어내기 때문이다. 여기에 관련된 2가지 중요한 툴이 있다.


1) 구글 웹마스터 (webmaster)
웹마스터는 싸이트 내용을 효율적으로 수집하는 작업을 도와준다. 여기에 적절한 양식대로 등록하면 구글 검색엔진에서 검색이 더 잘된다. (구글봇의 크롤링이 효율적으로 된다.) 한마디로 내 홈페이지 여기 저기에 어떤 자료가 있으니 가져가세요라고 안내해주는 작업이라고 보면 된다.

2) 구글 어낼리틱스 (analytics)
홈페이지의 통계와 정보를 수집해 준다. 오늘의 주제다.


보통 홈페이지 방문 통계하면 카운터만 생각한다. 내 홈페이지도 3달전까지만 해도 카운터만 달았다. 우연히 웹서핑하다가 analytics 를 본 순간 탄성이 터졌다. 쵝오!!


Google Analytics 는 홈페이지 방문객의 많은 정보를 제공한다.

국가, 지도상의 위치, 새로 온사람인지 이전에 방문했던 사람인지, 몇번째 방문인지, 언어, 방문객수, 중복된 방문객을 제외한 방문객수, 한사람당 페이지를 얼마나 넘기고 가는지, 홈페이지에 몇분 있다가 나가는지, 홈페이지 들어왔다가 보지도 않고 바로 나가는지 아닌지 (Bounce rate), 브라우저는 어떤 것을 쓰는지, 운영체제는 리눅스인지 윈도우인지, 화면 해상도는 무엇인지, 어떤 검색엔진을 타고 들어왔는지, 어떤 키워드를 입력해서 방문했는지, 모뎀인지 고속인터넷인지 등등등

정말 많은 것을 제공한다.


이건 내가 가지고 있는 도메인들이다.여기 안보이는 것까지 합쳐서 6개 의 domain 을 가지고 있다. 이 중에서 http://sshan.net 의 통계를 보자. 참고로 sshan.net 은 경제 관련 싸이트이다. 돈을 많이 벌고 싶다면 와서 열심히 읽으시라. ^^  컴퓨터만 열심히 해서는 가난한 일꾼으로 끝나는 경우도 많으니까...




요건 첫 화면이다. Dashboard 라고 나오는게 첫 화면이고 여기에는 내가 주로 보고 싶은 지표만 골라 놓고 볼 수 있다. 내가 매일 체크하는 지표는 Visit, Pageview, Bounce Rate, Avg. Time, New Visit 이 정도다.

아마 다른건 다 알겠지만 Bounce rate 이게 몰까요 ??? ㅋㅋ 나도 이게 뭔지 알려고 한참 찾았다.
한마디로 웹페이지 들어왔다가 보지도 않고 그냥 나간 사람의 비율이다. 페이지를 넘겨 보지도 않고 클릭도 안하고 나간 사람의 비율이다. bounce rate 따지는 기준은 회사마다 조금씩 다르지만 기본적으로 들어왔다가 그냥 나가는 사람의 비율을 체크하는 지표이다.

만약에 이효리 로 검색해서 싸이트에 들어갔는데 옥동자 홈페이지가 나왔다 보자. 남자들은 바로 나갈 것이다. 10 명 중에 9명이 바로 창을 닫아버렸다면 bounce rate 는 90% 이다. bounce rate 가 낮아야 좋은 홈페이지다. 블로그는 50% 이상으로 높은 경우가 많은데 대개 그 주제만 보고 나가기 때문에 그렇다. 따라서 블로그 운영하는 사람은 bounce rate 가 너무 낮아도 실망할 필요는 없다.



site 에 들어온 사람이 머문 시간이다. 여기 보면 마지막 날이 11:40 이고 그 다음은 5:50 이다. 전전날 통계가 11분 40초이고 전날 통계는 5분 50초라는 이야기이다. 5분 50초 이상하게 짧다. 전날까지 거의 대부분 11분 정도인데... 이건 버그인 듯 하다. site 시간 뿐 아니라 모든 analytics 의 전날 통계(bounce rate 등등 포함)가 부정확하다. 하지만 하루 지나면 정확하게 바뀐다.



absolute unique visit 라는 것은 중복된 방문 통계를 제외하는 것이다. 브라우저를 새로 열고 홈페이지를 방문하면 방문자 통계가 중복해서 잡힌다. 하지만 absolute unique visit 는 IP 를 확인하기 때문에 정확하다.

Bounce rate 는 아까 설명했는데... 표를 보면 이상하다.. 내 홈페이지는 bounce rate 가 80% 대였다가 갑자기 3~4% 정도로 바닥을 기고 있는 것을 볼 수 있다. 평균은 10.5% 이다.

이건... 내가 analytics 코드를 넣는 위치를 잘 못 넣었기 때문이다. analytics 코드는 웹페이지가 열릴때마다 .. 즉 페이지를 넘길 때마다 다시 load 되는 위치에 넣어야 한다.

요즘 많이 쓰는 원프레임 방식의 웹페이지는 별 문제 없다. 하지만 프레임을 나누는 경우에 클릭할 때마다 analytics 코드가 실행되게 해주어야 한다. 안그러면 analytics 가 잡아내지 못한다. 복잡한 이야기이지만 요즘 쓰는 tistory 나 daum, naver 블로그는 모두 원프레임 방식이다. 원프레임이 뭔지 모르겠다고 ?? 이것까지 설명하려면 너무 글이 길어진다. "홈페이지 프레임" 으로 검색해 보도록 !!



내가 analytics 하고 나서 제일 큰 수확이다. 사용자의 해상도를 알 수 있었다. 의외로 1024 x 768 이 많다. 나만 그런 줄 알았는데 다른 사람의 analytics 분석 결과도 1024 x 768 이 제일 많다.... 따라서 홈페이지를 1280 x 1024 같은 해상도로 최적화 했다가는 1/3 의 독자를 잃는 수가 있다. 웹페이지는 접근성이 중요하다. 나는 이것을 보자마자 sshan.net 을 1024 x 768 에 최적화 시켰다.



explore 를 많이 쓰지만 firefox, chrome, safari, opera 도 많이 쓴다. camino 는 나도 첨 듣는다. 참고로 나도 firefox 를 주로 쓴다. 속도가 예술이다.



- 통계자료는 새벽 0 시에 업데이트 된다. 따라서 오늘 설치했다면 통계는 내일 0 시에 집계될 것이다. 설치 후에 바로 안된다고 불평하지 말자.

- 기본으로 제공하는 javascript 로 설치하면 검색엔진이 전부 "search" 로 나온다. 이는 우리나라 검색엔진 등록이 안되있는 문제이다. 이 문제를 해결하려면 내가 작성한 글을 보시라. 50 군데 영문싸이트를 돌아다니면서 내린 최종 결론이며 잘 동작한다.

http://prettygom.com/entry/Google-Analytics-에-검색엔진-추가하기

- analytics 결과는 전날 데이터가 몇몇 데이터(bounce rate, visit ... )가 부정확하다. 하루 지나면 교정이 된다.

- analytics 코드는 페이지를 넘길 때마다 실행되는 위치에 넣어야 된다. 그래야 analytics 가 페이지를 넘겼는지... 이사람이 나갔는지.. 멍하고 있는지 등등을 알 수 있다.


오늘도 바빠 죽겠는데 길게 썼다. 이건 취미 생활인데... ㅋㅋ 하여튼 구글은 대단한 회사이다.


구글은 여러가지 다른 선물도 주고 있다.


 이중에 안쓰는 것 있으면 써보길 바란다. 감탄이 절로 나올 것이다.

요즘 블로그에 보면 트랙백이라는게 있다 이게 뭔가 ??

내가 여러 글을 읽어 보아지만 이해가 잘 안되었다.
http://nanum2.tistory.com/383
http://lawcher.com/149

그나마 이게 제일 이해하기 쉽게 써 있다.
http://cafe.daum.net/jigump/6OfD/1009


아래는 블로그에서 흔히 쓰는 댓글 양상이다.


글 아래에 제목 없이 글만 단다.


그런데 댓글을 길게 달고 싶다면 어떻게 할까 ???
그러니까 아래처럼 말이다. 아래는 다음 AGORA 의 예이다.



남의 블로그에 이렇게 답글을 달 수 없다. 블로그는 대개 개인 공간이라서 주인장만 글을 쓸 수 있다.
주인장이 답글을 쓸 수 있게 허락을 해주더라도... 티스토리 블로그에서 남기려면 티스토리 가입하고 네이버 블로그에서 남기려면 네이버 ID 를 가입해야한다. 오 마이 갓 !!!

이래서 생긴게 트랙백이다.
  
위에 있는 다음 AGORA 처럼 제목이 있는 긴 댓글을 자신의 블로그에 글을 쓴다.
그리고 원문의 트랙백 주소를 자신의 글에 적어주면 원문에 자신의 답글이 써졌다는 것이 전달된다.


아래는 내 글에 달린 트랙백이다.


내글에 대해서 "서울비의 알림" 이라는 제목으로 "Google Analytics 에 검색엔진 추가하기" 라는 글을 남겼다.
실제로 클릭해서 들어가보면... 똑같은 글이 나온다.


아래 도표는 http://cafe.daum.net/jigump/6OfD/1009 에서 가져온 것이다. 매우 쉽게 잘 그려 놓았다. 참고하시라.

 스마트 프라이싱이란 노출되는 광고가 효과적인가 아닌가에 따라 구글이 인센트브 또는 징벌을 가하는 것이라고 하겠다. 대부분 구글 애드센스에서 2가지가 문제가 되는데 1) 부정 클릭 2) 스마트 프라이싱 이다.

일단 스마트 프라이싱(smart pricing)의 정의는 아래와 같다.

<스마트 프라이싱의 정의>

스마트 프라이싱이란 쉽게 말하면 광고의 단가 조정이며
상세하게 말하면 계정마다 클릭당 지불을 차별화하여 지급하는 기능입니다.
이 기능은 2004년 4월부터 작동하고 있었다고 합니다.
광고주는 광고를 클릭하는 사람이
자신의 상품을 구매하여 매출을 올리는게 목적입니다.
근데 애드센스는 자신의 사이트에 들어온 사용자가 광고를 클릭만 하여도
사이트 운영자에게 수익을 줍니다.
그래서 광고클릭만 하고 물건을 사지 않는다면 광고주는 손해를 보게 됩니다.
계속적으로 클릭수는 많은데 구매률과 매출연결이 낮아지고 적어진다면
구글에서는 클릭으로 인한 애드센스 수입단가를 광고주를 배려하여
자동으로 다운 시켜버립니다.

 스마트 프라이싱을 어떻게 대응하느냐는 말이 많은데

1) 노출되는 광고를 줄여라 - 노출은 많고 클릭이 낮으면 단가가 낮아진다.
2) 블로그의 질을 올려라

 인데 1) 번에 대해서는 의견이 분분하다.

 스마트 프라이싱의 원리상 return on investment (RIO) 즉... 투자 회수율에 대해 이야기 하는데 ...

 문제는 나의 지식상 웹상에서 투자회수율(RIO) 를 알아내는 것은 불가능에 가깝다. 광고주에게 일일히 거래가 되었는지 물어보기도 힘들고 더구나 어떤 site 에서 온 손님이 구매를 했는지를 알기는 광고주의 web site 까지 관리하면 모를까 불가능하다.

 따라서 분명 다른 방법으로 스마트 프라이싱에 대한 데이터를 얻으리라 생각된다.

 가장 유력한 것은 Google Analytics 를 이용한 감시이다.




위의 그림처럼 구글은 analytics 를 통해 웹사이트의 정보를 정밀하게 얻는다.

광고 때리는 우리 싸이트와 광고주의 싸이트 양쪽에 analytics 분석툴이 설치되어 있다면 광고가 효과적으로 돌아가는지 알 수 있다.

예를 들어 우리 싸이트에서 "홍삼" 으로 클릭해서 광고주의 "홍삼원" 싸이트에 들어갔다고 하자.
만약 소비자가 "홍삼원"에 전혀 관심이 없는데 실수로 클릭 했다면 바로 나올 것이다.

이렇게 바로 나오면

1) bounce rate - 이 수치는 싸이트에 들어가서 클릭없이 바로 나오게 되면 올라가는 수치이다. 한마디로 전혀 관심없이 바로 나오는 경우 올라간다.
2) page view - 1 페이지 밖에 안 보았다.
3) average time - "홍삼원" 싸이트에 10 초나 접속했을래나?

이런 수치들이 엉망으로 나오게 된다. 추측컨데 구글은 이러한 데이터를 몇달정도 모아서 광고 단가를 정해주는 것으로 생각된다.

결국 bounce rate 가 낮고 page view 는 많고 site 에 머문 시간이 길어야 효과적으로 광고한 것이기 때문이다. 웹써핑 한 사람이 물건을 샀는지 안 샀는지는 사실 알 길이 없다.


여기까지 스마트 프라이싱에 대한 나의 추측이다. 동의하는가 ??? 동의한다면 추천 클릭 꽝~!! ^^

컴퓨터를 좀 안다고 생각했던 저도 rss 라는 것을 어제 알았습니다. 한마디로 각종 블로그나 기사를 골라읽기 위한 통신 규약이라고 생각하시면 됩니다. 비슷한 것으로 "atom" 이라는 것이 있습니다.

예를 들면 아고라의 "미네르바", 다음블로그의 "상승미소", 네이버블로그의 "드루킹" 님의 글을 읽는다고 합시다. 보통은 3개의 site 를 모두 즐겨찾기를 해놓고 한군데씩 들어가서 봅니다.

하지만 rss 를 이용하면 3 저자의 글을 한 화면에서 볼 수 있습니다 !!! 글도 시간 순서대로 정렬되어 있습니다.

rss 를 읽으려면 rss reader 라는 것이 있어야 하는데 쉽게 사용할 수 있는 rss reader 로는 google reader 가 있습니다. 이외에도 hanrss 등이 있습니다. rss 로 검색하면 나와요.

1) 일단 google.com 에 가입하시고.
2) http://reader.google.com 으로 들어갑니다.



왼쪽 위에 보면 구독 추가라고 되어 있습니다. 여기에 구독하고 싶은 rss 주소를 적어주면 됩니다.

3) rss 주소는 어디서 얻을까요 ?? "미네르바" 님의 rss 를 찾아보겠습니다. 아고라의 미네르바 님의 아이디를 클릭하면 아래처럼 나옵니다.

토론 2 옆에 보면 아까 보여드린  이 있습니다. 이걸 클릭하면 주소가 나옵니다.

이렇게 얻는 미네르바님의 rss 주소는
http://agora.media.daum.net/profile/rss.xml?key=yzcyxX5kuoE0&group_id=1

입니다. 이 주소를 2) 번에서 보여드린 google reader 의 구독 추가란에 적어주시면 됩니다.

현재 거의 모든 블로그 및 뉴스 기사 등이 rss 를 지원합니다. 잘 찾아보면 마크를 찾을 수 있습니다.

4) 결과입니다. 글이 잘 정렬되어 있습니다.




rss 로 많은 site 를 등록해서 본다면 시간도 절약하고 아고라의 알밥들도 피해갈 수 있으리라 생각됩니다. 몇몇 까페에서는 사람들이 죽어라 퍼나르고 있는데 이런 수고를 할 필요가 없습니다.

사실 저도 rss 를 모르고 열심히 비슷한 기능이 있는 홈페이지를 만드느라 고생 좀 했습니다. 진작 알았으면 이런 수고를 덜었겠죠. 그래도 많은 글들이 많이 있는 편리한 site 입니다. 많이 놀러와주세요.
http://sshan.net

Analytics 로 결과를 보면 검색엔진이 전부 "search" 로 나온다.
이는 네이버 / 다음 과 같은 검색 site 가 등록이 안되어 있어서 발생하는 문제이다.
검색엔진을 등록하면 해결할 수 있다.

google 의 help 를 보면

pageTracker._addOrganic("name_of_searchengine","q_var");

로 등록하라고 한다. name_of_searchengine 은 검색 엔진의 고유한 주소이고 q_var 는 검색 키워드가 저장되는 변수명이다.


예를 들면 엠파스의 경우 "keyword" 로 검색버튼을 누르면 주소창에

http://search.empas.com/search/all.html?z=A&q=keyword&x=0&y=0&qn=&s=&f=&bd=&bw=&tq=

라고 뜨는 것을 볼 수 있다. search.empas.com 이 검색 엔진 주소이고 &q=keyword 에서 q 가 검색값인 "keyword" 가 저장되는 장소이다. 따라서

pageTracker._addOrganic("empas","q");

를 추가하면 된다.

한가지 문제가 더 있는데 구글은 search 가 들어가는 주소를 "search"라는 검색엔진으로 등록하고 있다. 이것을 무시하게 만들어야 한다.

pageTracker._clearOrganic();

를 앞에 추가하자.

cf) 원래는 pageTracker._addIgnoredOrganic("search"); 만 해도 search 가 삭제되야 하는데 버그가 있는 것 같다. pageTracker._clearOrganic(); 을 추가해서 모든 검색엔진 정보를 지웠다. 이경우에는 search 엔진을 전부 등록해 주어야한다. 우리나라에서 쓰는 엔진 위주로 올렸다.

아래는 내가 쓰는 analytics 코드이다. "UA-XXXXXX-X" 부분을 자신의 것으로 바꾸어 쓰면 된다. 아래 코드를 모두 </body> tag 전에 삽입하면 인식이 된다.

ps) 아래에 UA-@@@@@@-@ 는 자신의 것으로 바꾸어야 한다.



<script type="text/javascript">
var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
</script>
<script type="text/javascript">
try {
var pageTracker = _gat._getTracker("UA-@@@@@@-@");
pageTracker._clearOrganic();
pageTracker._addOrganic("naver.com","query");
pageTracker._addOrganic("daum.net","q");
pageTracker._addOrganic("nate.com","q");
pageTracker._addOrganic("empas.com","q");
pageTracker._addOrganic("google.com","q");
pageTracker._addOrganic("paran.com","Query");
pageTracker._addOrganic("yahoo.com","p");
pageTracker._trackPageview();
} catch(err) {}</script>



http://www.antezeta.com/blog/google-analytics-search-engines

http://www.google.com/support/googleanalytics/bin/answer.py?answer=57046

http://www.google.com/support/googleanalytics/bin/answer.py?answer=55479

http://mldonkey.sourceforge.net/

donkey(당나귀)는 p2p 프로그램의 대명사입니다. 많이 쓰이는 overnet 도 donkey 에서 힌트를 얻어 나왔지요. overnet 과 donkey 의 차이는 donkey 는 중앙 서버가 필요한 반면에 overnet 의 경우에는 중앙 서버가 필요없는 완벽한 p2p 라고 할 수 있겠습니다.

하여튼 donkey 는 이미 소스가 공개 되어서 emule, aMule, xMule, 푸루나 등의 clone 이 만들어졌습니다. 안의 구조는 같지만 사용하기 편하게 조금씩 바꾼 프로그램들이지요.

그 중에서 가장 특징이 있는 donkey 를 꼽는다면 주저없이 mldonkey 를 꼽겠습니다. mldonkey 는 두가지 중요한 특징이 있습니다.

1) explore 로 원격 제어가 가능하다.

다른 donkey 와 다르게 mldonkey 는 인터넷 explore 를 통해 접근이 가능합니다. 아래는 explore 에서 본 mldonkey 의 제어창입니다.



2) 사용자 계정 설정이 가능하다.

 mldonkey 내에서는 사용자 설정을 할 수 있습니다. 저희 집 같은 경우 신발장에 donkey 서버가 있습니다. 물론 mldonkey 도 설치되어 있지요. mldonkey 안에 3명의 계정이 있답니다. 각각의 사람이 접속해서 자료를 다운을 걸어 놓으면 자신의 계정 폴더에 다운로드됩니다.


 donkey 의 가장 큰 문제는 느린 다운 속도였습니다. 이 때문에 donkey 프로그램을 하루종일 켜놓는 경우가 많죠. 하지만 donkey 하나 쓸려고 컴퓨터를 하루종일 켜 놓는 것은 낭비입니다. mldonkey 가 없다면 형이랑 동생이랑 둘다 donkey 를 사용한다면 컴퓨터를 2대 켜놓아야 합니다. 하지만 mldonkey 를 쓰면 mldonkey 가 설치된 컴퓨터 한대가 계속 일을 하게 됩니다. 형/동생 계정으로 다운로드를 제어하면 되지요.

 저희 집 같은 경우 신발장에 자료 저장용 linux 컴퓨터가 있는에 이 녀석이 mldonkey 서버 역할을 하고 있습니다. 우리집 식구는 모두 mldonkey 계정이 있습니다. 일단 자료만 걸어 놓으면 하루종일 받고 있습니다. 똘똘한 놈이지요.


 

제가 아는 인터넷 앨범 프로그램에 가장 많이 쓰이는 것은 2가지 있습니다.

1) Gallery (http://gallery.menalto.com)

2) album.pl (http://perl.bobbitt.ca/album)



입니다. 두개 중에 우열을 가린다면 Gallery 가 압승입니다. album.pl 은 perl 로 만들어져 있는데 아무래도 php 로 만들어진 gallery 보다 느립니다. 서버에 부하도 많이 줍니다.

제가 사용하는 gallery 는 ubuntu linux 에서 자동 업데이트 되는 버젼으로 사용합니다. 아무래도 apt-get(우분투 프로그램 업데이터) 으로 업데이트 하는 것이 편하니까요.

제 홈페이지(http://whria.net) 와 보시면 photography 부분이 있습니다. 이것은 gallery 로 만들어져 있습니다. 매우 짜임새있고 좋습니다. 단점이라면 댓글 다는 부분이 조금 부족합니다.

유니 코드 (UTF-8 or UTF-16LE) 를 local (아스키 또는 각자의 codepage) 로 변환시키는 문제는 유니코드 지원 프로그래밍을 위해서는 매우 복잡한 문제이다.

먼저 보통 말하는 local codepage 랑 아스키랑 같은 것이라는 것을 알자. 나는 처음에 이게 차이가 있을 까봐 정말 머리가 아팠다.

결국...

UTF8 <-> UTF16LE
UTF16LE <-> UTF8
UTF8 <-> local
UTF16LE <-> local

이렇게 4 가지 조합만 바꿀 수 있으면 unicode 를 완벽하게 지원하는 프로그램을 짤 수 있다.

c++ 에서 사용할 수 있는 locale 을 바꿔 주는 library 가 몇가지 있는데...

1) iconv
2) boost
3) qt 의 qstring
4) 그리고 피부미인의 codechanger ㅋㅋㅋ

1 번은 가장 많이 쓰는데 static 으로 compile 할라면 머리아프다. 나는 DLL 을 정말 싫어한다.
2 번은 사람들이 잘 모르는데 boost 안에 일부 function 이 unicode 프로그래밍의 중요한 clue 를 제공한다. 여기서 개발된 것이 4 번의 피부미인의 codechanger 이다.
3 번 qt 는 일단 install 할라면 너무 머리아프다. build 하다가 다른 library 랑 부딛치면 돌아버린다.

4 번 피부미인의 codechanger 는 내가 medicalphoto 라는 프로젝트를 하면서 정말정말 어렵게 만든겁니다.  여기에만 특별히 공개하겠습니다. ^^g 이걸 쓰려면 boost library 를 설치해야합니다. 아니면 utf8-codecvt_facet.hpp 에 있는 boost/config.hpp 나 boost/detail/workaround.hpp 등만 copy 해서 사용해도 됩니다.


사용법은 아래와 같다.

MCodeChanger::_CCL("unicode letters") = "local code letters"
MCodeChanger::_CCU("local code letters") = "unicode letters"



1. codechanger.h

////////////////////////////////////////////////////////////////////////////////
// Copyright : Han Seung Seog
// It was so damn hard to make this library
// http://prettygom.com
// http://sshan.net
// 2008. 8. 1
////////////////////////////////////////////////////////////////////////////////

#pragma once

#include "../boost.h"
#include <string>
#include <boost/format.hpp>
#include "tchar.h"
#include "utf8_codecvt_facet.hpp"
#include "unicode.h"

#ifdef _UNICODE
    #define _CCL U_W
    #define _CCU W_U
    #define _CCW mbs_to_wcs
    #define _CCN wcs_to_mbs
#else
    #define _CCL U_L
    #define _CCU L_U
    #define _CCW LocaltoLocal
    #define _CCN LocaltoLocal
#endif // _UNICODE

class MCodeChanger
{
public:
    static tstring LocaltoLocal(const tstring& str)
    {
        return str;
    }

    static std::string L_U(const std::string& str)
    {
        std::locale local(std::locale(""),new utf8_codecvt_facet);
        return wcs_to_mbs(mbs_to_wcs(str),local);
    }
    static std::string U_L(const std::string& str)
    {
        std::locale local(std::locale(""),new utf8_codecvt_facet);
        return wcs_to_mbs(mbs_to_wcs(str,local));
    }
    static std::string W_U(const std::wstring& str)
    {
        std::locale local(std::locale(""),new utf8_codecvt_facet);
        return wcs_to_mbs(str,local);
    }
    static std::wstring U_W(const std::string& str)
    {
        std::locale local(std::locale(""),new utf8_codecvt_facet);
        return mbs_to_wcs(str,local);
    }

static std::wstring
mbs_to_wcs(std::string const& str, std::locale const& loc = std::locale(""))
{
    typedef std::codecvt<wchar_t, char, std::mbstate_t> codecvt_t;
    codecvt_t const& codecvt = std::use_facet<codecvt_t>(loc);
    std::mbstate_t state = 0;
    std::vector<wchar_t> buf(str.size() + 1);
    char const* in_next = str.c_str();
    wchar_t* out_next = &buf[0];
    codecvt_t::result r = codecvt.in(state,
        str.c_str(), str.c_str() + str.size(), in_next,
        &buf[0], &buf[0] + buf.size(), out_next);
    return std::wstring(&buf[0]);
}
 
static std::string
wcs_to_mbs(std::wstring const& str, std::locale const& loc = std::locale(""))
{
    typedef std::codecvt<wchar_t, char, std::mbstate_t> codecvt_t;
    codecvt_t const& codecvt = std::use_facet<codecvt_t>(loc);
    std::mbstate_t state = 0;
    std::vector<char> buf((str.size() + 1) * codecvt.max_length());
    wchar_t const* in_next = str.c_str();
    char* out_next = &buf[0];
    codecvt_t::result r = codecvt.out(state,
        str.c_str(), str.c_str() + str.size(), in_next,
        &buf[0], &buf[0] + buf.size(), out_next);
    return std::string(&buf[0]);
}
};

2. [ utf8_codesvt_facet.hpp ]

// Copyright ?2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
// Distributed under the Boost Software License, Version 1.0. (See accompany-
// ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#pragma once

// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif

/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// utf8_codecvt_facet.hpp

// This header defines class utf8_codecvt_facet, derived fro
// std::codecvt<wchar_t, char>, which can be used to convert utf8 data in
// files into wchar_t strings in the application.
//
// The header is NOT STANDALONE, and is not to be included by the USER.
// There are at least two libraries which want to use this functionality, and
// we want to avoid code duplication. It would be possible to create utf8
// library, but:
// - this requires review process first
// - in the case, when linking the a library which uses utf8
//   (say 'program_options'), user should also link to the utf8 library.
//   This seems inconvenient, and asking a user to link to an unrevieved
//   library is strange.
// Until the above points are fixed, a library which wants to use utf8 must:
// - include this header from one of it's headers or sources
// - include the corresponding .cpp file from one of the sources
// - before including either file, the library must define
//   - BOOST_UTF8_BEGIN_NAMESPACE to the namespace declaration that must be used
//   - BOOST_UTF8_END_NAMESPACE to the code to close the previous namespace
//   - declaration.
//   -  -- to the code which must be used for all 'exportable'
//     symbols.
//
// For example, program_options library might contain:
//    #define BOOST_UTF8_BEGIN_NAMESPACE <backslash character>
//             namespace boost { namespace program_options {
//    #define BOOST_UTF8_END_NAMESPACE }}
//    #define  BOOST_PROGRAM_OPTIONS_DECL
//    #include "../../detail/utf8/utf8_codecvt.cpp"
//
// Essentially, each library will have its own copy of utf8 code, in
// different namespaces.

// Note:(Robert Ramey).  I have made the following alterations in the original
// code.
// a) Rendered utf8_codecvt<wchar_t, char>  with using templates
// b) Move longer functions outside class definition to prevent inlining
// and make code smaller
// c) added on a derived class to permit translation to/from current
// locale to utf8

//  See http://www.boost.org for updates, documentation, and revision history.

// archives stored as text - note these ar templated on the basic
// stream templates to accommodate wide (and other?) kind of characters
//
// note the fact that on libraries without wide characters, ostream is
// is not a specialization of basic_ostream which in fact is not defined
// in such cases.   So we can't use basic_ostream<OStream::char_type> but rather
// use two template parameters
//
// utf8_codecvt_facet
//   This is an implementation of a std::codecvt facet for translating
//   from UTF-8 externally to UCS-4.  Note that this is not tied to
//   any specific types in order to allow customization on platforms
//   where wchar_t is not big enough.
//
// NOTES:  The current implementation jumps through some unpleasant hoops in
// order to deal with signed character types.  As a std::codecvt_base::result,
// it is necessary  for the ExternType to be convertible to unsigned  char.
// I chose not to tie the extern_type explicitly to char. But if any combination
// of types other than <wchar_t,char_t> is used, then std::codecvt must be
// specialized on those types for this to work.

#include <locale>
// for mbstate_t
#include <wchar.h>
// for std::size_t
#include <cstddef>

#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>

namespace std {
    #if defined(__LIBCOMO__)
        using ::mbstate_t;
    #elif defined(BOOST_DINKUMWARE_STDLIB) && !defined(__BORLANDC__)
        using ::mbstate_t;
    #elif defined(__SGI_STL_PORT)
    #elif defined(BOOST_NO_STDC_NAMESPACE)
        using ::mbstate_t;
        using ::codecvt;
    #endif
} // namespace std

#if !defined(__MSL_CPP__) && !defined(__LIBCOMO__)
    #define BOOST_CODECVT_DO_LENGTH_CONST const
#else
    #define BOOST_CODECVT_DO_LENGTH_CONST
#endif

// maximum lenght of a multibyte string
#define MB_LENGTH_MAX 8

struct  utf8_codecvt_facet :
    public std::codecvt<wchar_t, char, std::mbstate_t> 
{
public:
    explicit utf8_codecvt_facet(std::size_t no_locale_manage=0)
        : std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage)
    {}
protected:
    virtual std::codecvt_base::result do_in(
        std::mbstate_t& state,
        const char * from,
        const char * from_end,
        const char * & from_next,
        wchar_t * to,
        wchar_t * to_end,
        wchar_t*& to_next
    ) const;

    virtual std::codecvt_base::result do_out(
        std::mbstate_t & state, const wchar_t * from,
        const wchar_t * from_end, const wchar_t*  & from_next,
        char * to, char * to_end, char * & to_next
    ) const;

    bool invalid_continuing_octet(unsigned char octet_1) const {
        return (octet_1 < 0x80|| 0xbf< octet_1);
    }

    bool invalid_leading_octet(unsigned char octet_1)   const {
        return (0x7f < octet_1 && octet_1 < 0xc0) ||
            (octet_1 > 0xfd);
    }

    // continuing octets = octets except for the leading octet
    static unsigned int get_cont_octet_count(unsigned   char lead_octet) {
        return get_octet_count(lead_octet) - 1;
    }

    static unsigned int get_octet_count(unsigned char   lead_octet);

    // How many "continuing octets" will be needed for this word
    // ==   total octets - 1.
    int get_cont_octet_out_count(wchar_t word) const ;

    virtual bool do_always_noconv() const throw() { return false; }

    // UTF-8 isn't really stateful since we rewind on partial conversions
    virtual std::codecvt_base::result do_unshift(
        std::mbstate_t&,
        char * from,
        char * /*to*/,
        char * & next
    ) const
    {
        next = from;
        return ok;
    }

    virtual int do_encoding() const throw() {
        const int variable_byte_external_encoding=0;
        return variable_byte_external_encoding;
    }

    // How many char objects can I process to get <= max_limit
    // wchar_t objects?
    virtual int do_length(
        BOOST_CODECVT_DO_LENGTH_CONST std::mbstate_t &,
        const char * from,
        const char * from_end,
        std::size_t max_limit
#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
        ) const throw();
#else
        ) const;
#endif

    // Largest possible value do_length(state,from,from_end,1) could return.
    virtual int do_max_length() const throw () {
        return 6; // largest UTF-8 encoding of a UCS-4 character
    }
};


3. [utf8_codecvt_facet.cpp]

/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// utf8_codecvt_facet.cpp

// Copyright ?2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu).
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

// Please see the comments in <boost/detail/utf8_codecvt_facet.hpp> to
// learn how this file should be used.
#include "stdafx.h"
#include "utf8_codecvt_facet.hpp"

#include <cstdlib> // for multi-byte converson routines
#include <cassert>

#include <boost/limits.hpp>
#include <boost/config.hpp>

// If we don't have wstring, then Unicode support
// is not available anyway, so we don't need to even
// compiler this file. This also fixes the problem
// with mingw, which can compile this file, but will
// generate link error when building DLL.
#ifndef BOOST_NO_STD_WSTRING

/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// implementation for wchar_t

// Translate incoming UTF-8 into UCS-4
std::codecvt_base::result utf8_codecvt_facet::do_in(
    std::mbstate_t& /*state*/,
    const char * from,
    const char * from_end,
    const char * & from_next,
    wchar_t * to,
    wchar_t * to_end,
    wchar_t * & to_next
) const {
    // Basic algorithm:  The first octet determines how many
    // octets total make up the UCS-4 character.  The remaining
    // "continuing octets" all begin with "10". To convert, subtract
    // the amount that specifies the number of octets from the first
    // octet.  Subtract 0x80 (1000 0000) from each continuing octet,
    // then mash the whole lot together.  Note that each continuing
    // octet only uses 6 bits as unique values, so only shift by
    // multiples of 6 to combine.
    while (from != from_end && to != to_end) {

        // Error checking   on the first octet
        if (invalid_leading_octet(*from)){
            from_next = from;
            to_next = to;
            return std::codecvt_base::error;
        }

        // The first octet is   adjusted by a value dependent upon
        // the number   of "continuing octets" encoding the character
        const   int cont_octet_count = get_cont_octet_count(*from);
        const   wchar_t octet1_modifier_table[] =   {
            0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc
        };

        // The unsigned char conversion is necessary in case char is
        // signed   (I learned this the hard way)
        wchar_t ucs_result =
            (unsigned char)(*from++) - octet1_modifier_table[cont_octet_count];

        // Invariants   :
        //   1) At the start of the loop,   'i' continuing characters have been
        //    processed
        //   2) *from   points to the next continuing character to be processed.
        int i   = 0;
        while(i != cont_octet_count && from != from_end) {

            // Error checking on continuing characters
            if (invalid_continuing_octet(*from)) {
                from_next   = from;
                to_next =   to;
                return std::codecvt_base::error;
            }

            ucs_result *= (1 << 6);

            // each continuing character has an extra (10xxxxxx)b attached to
            // it that must be removed.
            ucs_result += (unsigned char)(*from++) - 0x80;
            ++i;
        }

        // If   the buffer ends with an incomplete unicode character...
        if (from == from_end && i   != cont_octet_count) {
            // rewind "from" to before the current character translation
            from_next = from - (i+1);
            to_next = to;
            return std::codecvt_base::partial;
        }
        *to++   = ucs_result;
    }
    from_next = from;
    to_next = to;

    // Were we done converting or did we run out of destination space?
    if(from == from_end) return std::codecvt_base::ok;
    else return std::codecvt_base::partial;
}

std::codecvt_base::result utf8_codecvt_facet::do_out(
    std::mbstate_t& /*state*/,
    const wchar_t *   from,
    const wchar_t * from_end,
    const wchar_t * & from_next,
    char * to,
    char * to_end,
    char * & to_next
) const
{
    // RG - consider merging this table with the other one
    const wchar_t octet1_modifier_table[] = {
        0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc
    };

    wchar_t max_wchar = (std::numeric_limits<wchar_t>::max)();
    while (from != from_end && to != to_end) {

        // Check for invalid UCS-4 character
        if (*from  > max_wchar) {
            from_next = from;
            to_next = to;
            return std::codecvt_base::error;
        }

        int cont_octet_count = get_cont_octet_out_count(*from);

        // RG  - comment this formula better
        int shift_exponent = (cont_octet_count) *   6;

        // Process the first character
        *to++ = static_cast<char>(octet1_modifier_table[cont_octet_count] +
            (unsigned char)(*from / (1 << shift_exponent)));

        // Process the continuation characters
        // Invariants: At   the start of the loop:
        //   1) 'i' continuing octets   have been generated
        //   2) '*to'   points to the next location to place an octet
        //   3) shift_exponent is   6 more than needed for the next octet
        int i   = 0;
        while   (i != cont_octet_count && to != to_end) {
            shift_exponent -= 6;
            *to++ = static_cast<char>(0x80 + ((*from / (1 << shift_exponent)) % (1 << 6)));
            ++i;
        }
        // If   we filled up the out buffer before encoding the character
        if(to   == to_end && i != cont_octet_count) {
            from_next = from;
            to_next = to - (i+1);
            return std::codecvt_base::partial;
        }
        *from++;
    }
    from_next = from;
    to_next = to;
    // Were we done or did we run out of destination space
    if(from == from_end) return std::codecvt_base::ok;
    else return std::codecvt_base::partial;
}

// How many char objects can I process to get <= max_limit
// wchar_t objects?
int utf8_codecvt_facet::do_length(
    BOOST_CODECVT_DO_LENGTH_CONST std::mbstate_t &,
    const char * from,
    const char * from_end,
    std::size_t max_limit
#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
) const throw()
#else
) const
#endif
{
    // RG - this code is confusing!  I need a better way to express it.
    // and test cases.

    // Invariants:
    // 1) last_octet_count has the size of the last measured character
    // 2) char_count holds the number of characters shown to fit
    // within the bounds so far (no greater than max_limit)
    // 3) from_next points to the octet 'last_octet_count' before the
    // last measured character. 
    int last_octet_count=0;
    std::size_t char_count = 0;
    const char* from_next = from;
    // Use "<" because the buffer may represent incomplete characters
    while (from_next+last_octet_count <= from_end && char_count <= max_limit) {
        from_next += last_octet_count;
        last_octet_count = (get_octet_count(*from_next));
        ++char_count;
    }
    return static_cast<int>(from_next-from_end);
}

unsigned int utf8_codecvt_facet::get_octet_count(
    unsigned char   lead_octet
){
    // if the 0-bit (MSB) is 0, then 1 character
    if (lead_octet <= 0x7f) return 1;

    // Otherwise the count number of consecutive 1 bits starting at MSB
//    assert(0xc0 <= lead_octet && lead_octet <= 0xfd);

    if (0xc0 <= lead_octet && lead_octet <= 0xdf) return 2;
    else if (0xe0 <= lead_octet && lead_octet <= 0xef) return 3;
    else if (0xf0 <= lead_octet && lead_octet <= 0xf7) return 4;
    else if (0xf8 <= lead_octet && lead_octet <= 0xfb) return 5;
    else return 6;
}

namespace {
template<std::size_t s>
int get_cont_octet_out_count_impl(wchar_t word){
    if (word < 0x80) {
        return 0;
    }
    if (word < 0x800) {
        return 1;
    }
    return 2;
}

// note the following code will generate on some platforms where
// wchar_t is defined as UCS2.  The warnings are superfluous as
// the specialization is never instantitiated with such compilers.
template<>
int get_cont_octet_out_count_impl<4>(wchar_t word){
    if (word < 0x80) {
        return 0;
    }
    if (word < 0x800) {
        return 1;
    }
    if (word < 0x10000) {
        return 2;
    }
    if (word < 0x200000) {
        return 3;
    }
    if (word < 0x4000000) {
        return 4;
    }
    return 5;
}

} // namespace anonymous

// How many "continuing octets" will be needed for this word
// ==   total octets - 1.
int utf8_codecvt_facet::get_cont_octet_out_count(
    wchar_t word
) const {
    return get_cont_octet_out_count_impl<sizeof(wchar_t)>(word);
}


#endif

원래 컴퓨터 문자의 시초는 아스키 코드다. 아스키 코드에서는 1 문자는 1 byte 로 이루어져 있다.

하지만 이것으로는 모든 문자를 표현하는 것이 불가능하다. 요즘처럼 글로벌 시대에 다국어를 표현하려면 1 byte 는 많이 부족하다 특히 한글은 전세계 언어중에서 가장 큰 다양성을 가지고 있는데 모두 다 조합하면 다른 언어 다 합친것의 절반이상의 용량을 차지한다. 세종대왕님 감사합니다. ^^

다국어 뿐만 아니라 특수 문자 문제도 있기 때문에 적어도 2 byte 의 길이를 가진 code set 이 필요하게 되었다.

하지만 컴퓨터는 미국에서 개발되었고 걔네들은 2byte 쓸 이유가 없다. 특히 램값이 금값인 시절에 문자열 하나에는 1 byte 이상 차지하는 건 사치다. 그래서 1 byte = 1 문자로 최근까지 이어져왔다. 하지만 우리나라 같은 곳에서는 어쩔 수 없이 편법을 써서라도 한글을 표현해야 했고, 이를 극복하기 위해서 쓰는 대표적인 개념이 codepage 라는 개념이다.

데이터는 고정된 상태에서 codepage 에 따라 보이는 모양이 변한다. 예전에 일본 게임을 한국 윈도우에서 실행하면 메뉴의 글이 깨지는 것을 볼 수 있다. code page 가 일본으로 설정되어 있어야 제대로 보이기 때문이다. 하지만 일본 게임의 일본어를 보기위해 기본 code page 를 일본으로 설정하면 한글 윈도우 내의 다른 모든 한글이 엉망이 되버리는 문제가 있다.


이러한 문제로 개발 된 것이 unicode 이다.
모든 문자셋 + 기호를 지원하기 위해 2 byte 이상의 용량을 차지하는 문자셋을 개발한 것이다.

윈도우도 windows 2000 부터는 문자 set 으로 unicode 가 사용되었다. 기존의 아스키 코드가 1 byte 라면 window 에서 사용하는 unicode 는 2 byte 로 고정되어 있는 UTF16LE (little edition) 을 사용한다. 참고로 대부분의 unix 계열은 UTF-8 을 사용한다.

나도 처음에 unicode 하면 UTF16LE 인줄 알았다. 근데 잘 보니 unicode 에 종류가 무척 많다. 다 기억은 못하지만 UTF16BE (big edition) 도 있다. 다 알것 없고 unicode 는 2가지를 많이 쓴다고만 알면 된다.

1) UTF16LE --> windows 2000, winxp, vista, windows 7 등의 unicode / 2 byte 고정
2) UTF-8 --> unix/linux 계열에서 사용 / mysql 등의 database 에서 사용 / web 에서 표준 / 1 byte ~ 4 byte 가변
 
즉 많이 쓰는 것은 UTF16LE 와 UTF-8 두가지다.
 
UTF-8 이 참 재미있는 녀석인데 이놈은 개발 당시부터 아스키를 기준으로 만들어진 기존 프로그램을 그대로 이용하기 위해서 만들어졌다. 따라서 아스키 문자열과 호환이 된다. 하지만 1 byte 인 아스키 문자열이 커버하지 못하는 부분을 1 byte ~ 4 byte 까지 더 확장해서 표현한다. 그리고 문자열 중간에 null code 가 없기 때문에 기존 아스키 프로그램에 잘 돌아간다. 이런 이유로 unix 계열 / web / database 에서 unicode 하면 대부분 UTF-8 이다.

UTF16LE 는 마이크로 소프트 윈도우즈에서 사용되는 2 byte 문자셋이다. 장점은 문자열 길이 잴때 편하다(무조건 2로 나누면 되니깐... UTF-8 은 한문자가 몇바이트인지 앞에서부터 세보지 않으면 알 수 없다.)는 것 빼고는 다른 면에서 UTF-8 보다 뭐가 좋은지 잘 모르겠다. 결정적으로 기존 아스키 프로그램에 호환이 안되기 때문에 프로그램을 다시 짜야한다.

함수를 모조리 바꿔야 하는데 이게 보통 머리아픈게 아니다. 윈도우 내장 API 함수를 보면 MessageBoxA / MessageBoxW 이렇게 2가지가 있는데 A 로 끝나는 것은 기존의 아스키 함수 / W 는 Wide Character 를 쓰는 유니코드 함수이다. MFC 같은 라이브러리에서는 MessageBox 라고 하면 셋팅을 보고 알아서  MessageBoxA / MessageBoxW 중에 한놈으로 바꿔준다.


 


 

MedicalPhoto 는 의료용 사진관리 프로그램이다. 현재 의료용 사진관리 프로그램은 제대로 된 게 없다. 2004 년에 사진관리하기가 귀찮아서 만들었고 현재는 서울아산병원, 중앙대 병원 피부과에서 사용중이다. 무료 software 이다.

전세계인이 쓸 수 있는 사용하기 편한 의료용 사진관리 프로그램을 위해 개발되었다.

의사 입장에서 좋은 점은

1) 피부과 진단 코드가 거의다 들어있다. 거의 모든 textbook 에 있는 진단 코드와 ICD-10 코드 포함
2) 네트워크 지원으로 진료방에서 볼 수 있다.
3) 큰 화면을 지원하며 인터페이스가 직관적이라 사용이 편하다.
4) 자동 업데이트 지원

이 프로그램은 개발하면서 정말 오랜 시간이 걸렸다. 버그를 없애기 위해 엄청난 노력을 기울였다. 프로그래밍 입장에서 발전한 점은

1) 인스톨러 (ci installer 사용) & 웹 자동 업데이트
2) 서버-클라이언트 자동 업데이트
3) unicode 지원 (UTF-16LE & UTF-8)
4) Sqlite 데이터베이스로 사용
5) Joomla 로 홈페이지 작성 - maxmind 의 geographic tool 이용
6) GPL 라이센스를 따른다. - SVN 으로 코드 관리 중이다.
7) sourceforge.net 에 등록
8) pdf 토큐먼트 제공
9) 다중 모니터 지원


내가 지금까지 써본 상용 의료용 사진 관리 프로그램보다 훨씬 빠르고 강력하다. 프로그램은 installer 가 5 메가 정도로 작고 메모리도 순간 최고 20 메가 정도 밖에 안 차지한다.

http://medicalphoto.org