解説クラスＣｏｐｙＣｌｅａｒ（１１）
解説クラスＣｏｐｙＣｌｅａｒ（１１）
２０２４年３月１８初講（初稿）
この講義は解説『解説クラスＣｏｐｙＣｌｅａｒ（１０）』
の続きです！
２０２４年３月１８初講（初稿）
（４－１４－７）関数「int Convert(
TypeArray* ps,TypeArray* pd,TypeArray* lut){・・・｝」の説明
int CopyClear::Convert(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
TypeArray *lut // ＬＵＴ配列
){
TypeArray s; // Ｓ：サイズ補正後
TypeArray d; // Ｄ：サイズ補正後
int ws; // Ｓ配列の単位幅
int ll; // ｌｕｔ配列サイズ
int hv; // 水平／垂直幅
ws = ps->w; // 単位幅取出し：Ｓ
ll = lut->h; // サイズ取出し：LUT
if( ws == 1 ){ // Ｓが１Byte整数時
if( ll < 256 ){ // LUTSizeが不足なら
return( STI_ARY_2 - 30 ); // ３番引数エラー
} //
}else if( ws == 2 ){ // Ｓが２Byte整数時
if( ll < 65536 ){ // LUTSizeが不足なら
return( STI_ARY_2 - 30 ); // ３番引数エラー
} //
}else{ // 上記以外なら
return( STI_ARY_5 - 10 ); // １番引数エラー
} //
s = *ps; // Ｓ配列を補正する
ps = &s; // ため情報をコピー
d = *pd; // Ｄ配列を補正する
pd = &d; // ため情報をコピー
hv = ( ps->h < pd->h ) ? ps->h : pd->h; // 水平幅を最小で
ps->h = hv; // 補正
pd->h = hv; //
hv = ( ps->v < pd->v ) ? ps->v : pd->v; // 垂直幅を最小で
ps->v = hv; // 補正
pd->v = hv; //
if( ws == 1 ){ // Ｓが１Byte整数時
return( convert_b( ps, pd, lut ) ); // 左記で LUT変換
}else{ // Ｓが２Byte整数時
return( convert_w( ps, pd, lut ) ); // 左記で LUT変換
} //
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（４－１４－７－Ａ）関数「int Convert()」の【関数名】説明
「Convert」は、英単語「Convert」として変換するの意味で
す！ここの画像処理では、ＬＵＴ≪ルックアップテーブル≫
を使用したＳ（元）画像⇒ＬＵＴ変換⇒Ｄ（結果）画像への
画素データをＬＵＴ≪Lookuptable≫として一時的に変換す
る技法を使用して変換する関数です！
（４－１４－７－Ｂ）関数「int Convert()」の【返値】説明
int CopyClear::Convert(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
TypeArray *lut // ＬＵＴ配列
){特徴的なのは、仮引数「TypeArray* ps,」とＳ（元）画像の
画素単位「ps->w」が、１バイト単位の場合⇒仮引数「
TypeArray* lut」とＬＵＴを示す1次元配列のサイズ「
lut->h」が２５６未満ならば、エラー「STI_ARY_2-30」を
返し、２バイト単位の場合⇒ＬＵＴを示す1次元配列の
サイズ「lut->h」が６５５３６未満ならば、
エラー「STI_ARY_2-30」を返し、Ｓ（元）画像の画素
単位「ps->w」が、１や２で無い場合は、
エラー「STI_ARY_5-10」を返します！このエラーチェック
を通過したら、Ｓ（元）画像の画素単位「ps->w」が、
１バイト単位の場合⇒「return(convert_b(ps,pd,lut));」
でエラーチェックします、
２バイト単位の場合⇒「return(convert_w(ps,pd,lut));」
でエラーチェックします。
（４－１４－７－Ｃ）関数「int Convert()」の【仮引数】説明
int CopyClear::Convert(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
TypeArray *lut // ＬＵＴ配列
){「TypeArray* ps,」は、Ｓ（元）画像を示します！
「TypeArray* pd,」は、Ｄ（結果）画像を示します！
「TypeArray* lut」は、ＬＵＴを示す１次元配列です！
（４－１４－７－Ｄ）関数「int Convert()」の【アルゴリズム】説明
){
TypeArray s; // Ｓ：サイズ補正後
TypeArray d; // Ｄ：サイズ補正後
int ws; // Ｓ配列の単位幅
int ll; // ｌｕｔ配列サイズ
int hv; // 水平／垂直幅
ws = ps->w; // 単位幅取出し：Ｓ
ll = lut->h; // サイズ取出し：LUT
if( ws == 1 ){ // Ｓが１Byte整数時
if( ll < 256 ){ // LUTSizeが不足なら
return( STI_ARY_2 - 30 ); // ３番引数エラー
} //
}else if( ws == 2 ){ // Ｓが２Byte整数時
if( ll < 65536 ){ // LUTSizeが不足なら
return( STI_ARY_2 - 30 ); // ３番引数エラー
} //
}else{ // 上記以外なら
return( STI_ARY_5 - 10 ); // １番引数エラー
} //
s = *ps; // Ｓ配列を補正する
ps = &s; // ため情報をコピー
d = *pd; // Ｄ配列を補正する
pd = &d; // ため情報をコピー
hv = ( ps->h < pd->h ) ? ps->h : pd->h; // 水平幅を最小で
ps->h = hv; // 補正
pd->h = hv; //
hv = ( ps->v < pd->v ) ? ps->v : pd->v; // 垂直幅を最小で
ps->v = hv; // 補正
pd->v = hv; //
if( ws == 1 ){ // Ｓが１Byte整数時
return( convert_b( ps, pd, lut ) ); // 左記で LUT変換
}else{ // Ｓが２Byte整数時
return( convert_w( ps, pd, lut ) ); // 左記で LUT変換
} //
}ローカル変数
){
TypeArray s; // Ｓ：サイズ補正後
TypeArray d; // Ｄ：サイズ補正後
int ws; // Ｓ配列の単位幅
int ll; // ｌｕｔ配列サイズ
int hv; // 水平／垂直幅「TypeArray s;」は、内部でサイズを補正したＳ画像
「TypeArray d;」は、内部でサイズを補正したＤ画像
「int ws;」は仮引数「TypeArray* ps」の単位幅を扱い易く
取り出した値です！
「int ll;」は仮引数「TypeArray* lut」の水平幅≪１次元配列
扱いなので１次元のサイズ≫を扱い易く取り出した値です！
「int hv;」は、仮引数「TypeArray* ps,TypeArray* pd」
の水平幅／垂直幅の最小値（ＳＤ両者の有効幅）算出用です
アルゴリズムコード
ws = ps->w; // 単位幅取出し：Ｓ
ll = lut->h; // サイズ取出し：LUT
if( ws == 1 ){ // Ｓが１Byte整数時
if( ll < 256 ){ // LUTSizeが不足なら
return( STI_ARY_2 - 30 ); // ３番引数エラー
} //
}else if( ws == 2 ){ // Ｓが２Byte整数時
if( ll < 65536 ){ // LUTSizeが不足なら
return( STI_ARY_2 - 30 ); // ３番引数エラー
} //
}else{ // 上記以外なら
return( STI_ARY_5 - 10 ); // １番引数エラー
} //
s = *ps; // Ｓ配列を補正する
ps = &s; // ため情報をコピー
d = *pd; // Ｄ配列を補正する
pd = &d; // ため情報をコピー
hv = ( ps->h < pd->h ) ? ps->h : pd->h; // 水平幅を最小で
ps->h = hv; // 補正
pd->h = hv; //
hv = ( ps->v < pd->v ) ? ps->v : pd->v; // 垂直幅を最小で
ps->v = hv; // 補正
pd->v = hv; //
if( ws == 1 ){ // Ｓが１Byte整数時
return( convert_b( ps, pd, lut ) ); // 左記で LUT変換
}else{ // Ｓが２Byte整数時
return( convert_w( ps, pd, lut ) ); // 左記で LUT変換
} //
}「ws=ps->w;」は、Ｓ画像単位幅を扱い易く取り出し！
「ll=lut->h;」は、変換用ＬＵＴ１次元配列のサイズを
扱い易く取り出し！
「if(ws==1){・・左記条件成立１・・}else if(ws==2){
・・左記条件成立２・・}else{・・条件不成立・・}」は、
条件「ws==1」でＳ画像が１バイト単位の時、条件成立１を
実行で条件成立１「if(ll<256){return(STI_ARY_2-30);}」
でエラーチェックとしてＬＵＴのサイズが２５６未満≪詰り
１バイト画素の値が符号無し８ビット「０～２５５」に成る
ので対応するテーブルのサイズが２５６必要≫なのでエラー
として「STI_ARY_2-30」を返し関数終了「-30」と３番目の
「TypeArray* 」型仮引数に原因が有る事を示します！
条件「ws==2」でＳ画像が２バイト単位の時、条件成立２を
実行で
条件成立２「if(ll<65536){return(STI_ARY_2-30);}」で
エラーチェックとしてＬＵＴのサイズが６５５３６未満≪
詰り２バイト画素の値が符号無し１６ビット「０～
６５５３５」に成るので対応するテーブルのサイズが、
６５５３６必要≫なのでエラーとして「STI_ARY_2-30」を
返し関数終了！
そして「}else{」と条件不成立で
「return(STI_ARY_5-10);」とエラーチェックとしてＳ画像
が１バイト単位でも２バイト単位でも無い場合にエラーと
して「STI_ARY_5-10」を返し関数終了「-10」と１番目の
「TypeArray* 」型仮引数に原因が有る事を示します！
「s=*ps;ps=&s;」は、ローカル変数にＳ画像情報を一旦、
サイズ補正を考えてコピーして置きます！
「d=*pd;pd=&d;」もＤ画像情報の補正用です！
「hv=(ps->h<pd->h)?ps->h:pd->h;」は、ＳＤ両者水平幅の
最小値（有効幅）算出です！
「ps->h=hv;pd->h=hv;」は、ＳＤ両画像情報の
ローカル変数の水平幅を有効幅に補正します！
「hv=(ps->v<pd->v)?ps->v:pd->v;ps->v=hv;pd->v=hv;」
は、ＳＤ両画像情報のローカル変数の垂直幅を有効幅に補正
します！
「if(ws==1){return(convert_b(ps,pd,lut));
}else{return(convert_w(ps,pd,lut));}」は、
条件「ws==1」でＳ画像画素が１バイト単位の場合、
サブルーチン「convert_b()」で処理し結果の間数値を返し
条件不成立詰りＳ画像画素が２バイト単位の場合、
サブルーチン「convert_w()」で処理し結果の間数値を返し
関数終了！
（４－１４－７－Ｅ）関数「int Convert()」の【使用例】説明
{
TypeArray PatImg; // 画像型変数
// ：編か前のパターン画像
TypeArray* pPatImg=&PatImg; // 上記へのポインタ
TypeArray Wimg; // 画像型変数
//：フィル書き込み用
TypeArray* pWimg=&Wimg; // 上記へのポインタ
//：部分画像用
TypeArray* pimgA=&PatImg; // 部分画像用
TypeArray* pimgB=&PatImg; // 部分画像用
//：ＬＵＴ配列用
TypeArray ALut; // ＬＵＴ型変数
TypeArray* pLut=&ALut; // ＬＵＴ型ポインタ変数
BYTE lut[256]; // ＬＵＴ実体
long hgm[256]; // ヒストグラム算出データ配列
BYTE* p; // 画像画素へのポインタ
int i; // ループカウンタ
int x; // Ｘ座標
int y; // Ｙ座標
int d; // 画素データ
int t; // ２値化しきい値
int sti; // ステータス情報
pPatImg->MallocBYTE( 640, 480 ); // サイズ６４０×４８０画像メモリ取得
FUN.Clear( pPatImg, 0 ); // 画像メモリ「０クリア」
p = pPatImg->getPtrByte( 0, 0 ); //
for( x = 0; x < 640; x++ ){ //
d = x & 0x0ff; // 0..255の値にする
*p++ = d; // 画素として書き込む
} // １行分パターン画像作成
pimgA->subset( pPatImg, 0, 0, 640, 1 ); // 先頭行の部分画像
for( y = 1; y < 480; y++ ){ //
pimgB->subset( pPatImg, 0, y, 640, // ２行以降の任意場所の
1 ); // 部分画像
FUN.Copy( pimgA, pimgB ); // 先頭行のパターン画像を２行目以降にコピー
} // これで横方向インクリメントパターン画像作成
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap( "testFile5.bmp", pPatImg );
//ＬＵＴ変換サンプル：画素データ反転
pLut->SetByte( lut, 256, 1 ); // ＬＵＴ実体を「TypeArray*」にセット
for( i = 0; i < 256; i++ ){ // 極、普通の教科書的な記載でlut[0..255]の中の
lut[i] = 255 - i; // パターンが「255..0」と８ビット内データで
} // 反転している事が分かるでしょう！
pWimg->MallocBYTE( 640, 480 ); // サイズ６４０×４８０画像メモリ取得
FUN.Clear( pWimg, 0 ); // 画像メモリ「０クリア」
FUN.Convert( pPatImg, pWimg, pLut ); // 今回紹介する関数「Convert()」でＬＵＴ変換
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile6.bmp", pWimg );
// 典型的な２値化画像生成方法での処理
// サンプルパターン画像作成
FUN.Clear( pPatImg, 100 ); // 画像メモリ「画素データ100でクリア」
pimgA->subset( pPatImg, 100, 200, // 座標範囲（100,200）⇒（149,229）の範囲の
50, 30 ); // 部分画像を用意
FUN.Clear( pimgA, 200 ); // 部分画像を画素データ200でクリア
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile7.bmp", pPatImg );
// 典型的な２値化しきい値を算出する方法
FUN.HistogramImage( pPatImg, hgm ); // 画像の画素濃度ヒストグラム産出
t = FUN.GetBinOotu( hgm, 256 ); // 大津法と言う画像処理で一般的な産出手法で
// 濃度ヒストグラム・データから、しきい値産出
//ＬＵＴ変換サンプル：２値化
FUN.up_fill( 0, lut, t ); // ＬＵＴ配列の「0..t」を０クリアし
FUN.up_fill( 255, &lut[t], 256 - t ); // 「t..255」迄を２５５で書き込む事で
// ２値化ＬＵＴパターン作成
FUN.Convert( pPatImg, pWimg, pLut ); // 今回紹介する関数「Convert()」でＬＵＴ変換
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile8.bmp", pWimg );
// 後始末
pPatImg->freeMem(); // 画像メモリ解放
pWimg->freeMem(); // 画像メモリ解放
}使用例の変数等の定義
{
TypeArray PatImg; // 画像型変数
// ：編か前のパターン画像
TypeArray* pPatImg=&PatImg; // 上記へのポインタ
TypeArray Wimg; // 画像型変数
//：フィル書き込み用
TypeArray* pWimg=&Wimg; // 上記へのポインタ
//：部分画像用
TypeArray* pimgA=&PatImg; // 部分画像用
TypeArray* pimgB=&PatImg; // 部分画像用
//：ＬＵＴ配列用
TypeArray ALut; // ＬＵＴ型変数
TypeArray* pLut=&ALut; // ＬＵＴ型ポインタ変数
BYTE lut[256]; // ＬＵＴ実体
long hgm[256]; // ヒストグラム算出データ配列
BYTE* p; // 画像画素へのポインタ
int i; // ループカウンタ
int x; // Ｘ座標
int y; // Ｙ座標
int d; // 画素データ
int t; // ２値化しきい値
int sti; // ステータス情報「TypeArray PatImg;」は、例文サンプル用のパターン画像
で「TypeArray」型変数として定義する事で画像処理の画像
を意味する事を理解して下さい
「TypeArray* pPatImg=&PatImg;」は、画像処理関数では、
取り扱いが「TypeArray」型変数より、「TypeArray*」型と
ポインタの形の方が取り扱いし易く設計しているので一旦、
「TypeArray* pPatImg;」とポインタ変数を定義し、初期設
定で「TypeArray* pPatImg=&PatImg;」と割り当てて居る事
を理解して下さい！
「TypeArray Wimg;」は、例文サンプル用のパターン画像を
ＬＵＴ変換した結果画像を示し、「W」と有るのは結果画像
を画像ファイルに書き込む事を意味します！
「TypeArray* pWimg=&Wimg;」は、ポインタの形の方が取り
扱いし易く設計しているので一旦、「TypeArray* pWimg」と
ポインタ変数を定義し、初期設定で
「TypeArray* pWimg=&Wimg;」と割り当てて居る事を理解
して下さい！
「TypeArray* pimgA=&Patimg;」は、パターン画像作成時の
部分画像の定義用です！ここは、１行目の部分画像を表し
ます！
「TypeArray* pimgB=&Patimg;」は、パターン画像作成時の
部分画像の定義用です！ここは、２行目以降の部分画像を
表します！
「TypeArray ALut;」は、「TypeArray」型変数ですが、
画像で無く、一次元配列を示す事に注意して下さい！
「TypeArray* pLut=&ALut;」でコノ画像処理関数では、
取り扱いが「TypeArray」型変数より、「TypeArray*」型と
ポインタの形の方が取り扱いし易く設計しているので一旦、
「TypeArray* pLut=&ALut;」とポインタ変数を定義し、
初期設定で「TypeArray* pLut=&ALut;」と割り当てて居る
事を理解して下さい！
「BYTE lut[256];」は、「BYTE型＝unsigned char型」で
定義したＣ言語で教科書的に表現している配列データです！
「long hgm[256];」は、画像画素の濃度（画素の値）ヒス
トグラムデータを格納する配列で「long型」と４バイト整数
型の配列です！画像処理の中でカメラで撮影した自然画像か
ら、処理する為の２値化画像を得る為の２値化しきい値を
作成する処理で使用頻度が高いので特別に独立したクラス「
Ｈｉｓｔｏｇｒａｍ」を用意して居ます！ライブラリ関数の
元に成ったＡＤＳ社の画像処理装置ＩＰ－４には、特別に
一枚の基板でオプションボードとしてリアルタイムでヒス
トグラム産出する機能を備えて居ました？！その為にも
特別に独立したクラスとして作成したのが歴史的経緯です
が、２値化する為のしきい値を得るのが主な目的ですので
ここで説明する方式は、アッチコッチで使用する方式なので
使用方法は、覚えてね！
「BYTE* p;」は、画素単位で操作する為のポインタ変数
「int i;」は、ループカウンタ（インデックス）
「int x;」は、パターン画像作成時のＸ座標変数
「int y;」は、パターン画像作成時のＹ座標変数
「int d;」は、画素データ変数
「int t;」は、２値化しきい値
「int sti;」は、エラーコード
パターン画像作成
pPatImg->MallocBYTE( 640, 480 ); // サイズ６４０×４８０画像メモリ取得
FUN.Clear( pPatImg, 0 ); // 画像メモリ「０クリア」
p = getPtrByte( 0, 0 ); //
for( x = 0; x < 640; x++ ){ //
d = x & 0x0ff; // 0..255の値にする
*p++ = d; // 画素として書き込む
} // １行分パターン画像作成
pimgA->subset( pPatImg, 0, 0, 640, 1 ); // 先頭行の部分画像
for( y = 1; y < 480; y++ ){ //
pimgB->subset( pPatImg, 0, y, 640, // ２行以降の任意場所の
1 ); // 部分画像
FUN.Copy( pimgA, pimgB ); // 先頭行のパターン画像を２行目以降にコピー
} // これで横方向インクリメントパターン画像作成
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap( "testFile5.bmp", pPatImg );「pPatImg->MallocBYTE(640,480);」は、「TypeArray」
クラスのメソッド（メンバー関数）「MallocBYTE()」で
動的に画像メモリを取得！
「FUN.Clear(pPatImg,0);」は、画像画素全体を０クリア
「p=pPatImg->getPtrByte(0,0);」は、画像メモリの
座標（０，０）の画素ポインタ値を取得し変数「p」格納
「for(x=0;x<640;x++){d=x&0x0ff;*p++ = d;}」は、極、
教科書的≪実行速度的には改良の余地が有るが分かり易い
筈≫なのでコードを読んで頂ければ分かる様にインクリメ
ント≪ここでＣ言語のビット毎演算（『&演算子』使用）に
不慣れな読者様も居ると考えて解説【動作的には変数「x」
を２５６で除算した余りが「x&0x0ff」と成ります】、更に
「0x0ff」とヘキサデシマル記法で数値を記載したのは、
直接Ｃ言語文法では２進数表記が出来無いが「0x0ff」＝
２進数表記「11111111」と８ビット＝１バイト全てのビット
が「1」に成った事を私の様なデジタル電子回路技術者上が
りのプログラマーには分かり易いからです！≫
「pimgA->subset(pPatImg,0,0,640,1);」は、先頭行≪画像
の範囲が「（0,0）．．（639,0）」の部分画像を意味≫
「for(y=1;y<480;y++){・・ループ中身・・」は、極、
教科書的な説明記述でＹ座標を示す変数「y」を「1..479」
と繰り返しループ中身
「pimgB->subset(pPatImg,0,y,640,1);
FUN.Copy(pimgA,pimgB);」を繰り返します！ループ中身
「pimgB->subset(pPatImg,0,y,640,1);」は、部分画像とし
範囲が「（0,y）．．（639,y）」の部分画像を意味≪Ｙ座標
を変数「y」の値に変更した行を示す≫し、その部分画像へ
「FUN.Copy(pimgA,pimgB);」と先頭行の画像画素パターンを
コピーする事で横（Ｘ座標）方向インクリメント・パターン
画像を作成します！
「FUN.WriteBitmap("testFile5.bmp",pPatImg);」は、
ファイル名「"testFile5.bmp"」でＢＭＰ形式の画像ファイ
ル作成！
ＬＵＴ変換サンプル：画素データ反転
//ＬＵＴ変換サンプル：画素データ反転
pLut->SetByte( lut, 256, 1 ); // ＬＵＴ実体を「TypeArray*」にセット
for( i = 0; i < 256; i++ ){ // 極、普通の教科書的な記載でlut[0..255]の中の
lut[i] = 255 - i; // パターンが「255..0」と８ビット内データで
} // 反転している事が分かるでしょう！
pWimg->MallocBYTE( 640, 480 ); // サイズ６４０×４８０画像メモリ取得
FUN.Clear( pWimg, 0 ); // 画像メモリ「０クリア」
FUN.Convert( pPatImg, pWimg, pLut ); // 今回紹介する関数「Convert()」でＬＵＴ変換
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile6.bmp", pWimg );「pLut->SetByte(lut,256,1);」は、「TypeArray」クラスの
メソッド（メンバー関数）で「TypeArray型」のポインタ
変数「pLut」に「BYTE lut[256];」配列を割り当てる！
「for(i=0;i<256;i++){lut[i]=255-i;}」は、教科書的≪
実行速度的には改良の余地が有るが分かり易い筈≫なので
コードを読んで頂ければ分かる様にデクリメントパターン≪
降順に255..0と配列「BYTE lut[256];」の中身を生成≫に成
る事は理解して下さい！補足≪「255-i」で「0⇒255、
1⇒254、2⇒253・・・・254⇒1、255⇒0」に成る≫
「pWimg->MallocBYTE(640,480);FUN.Clear(pWimg,0);」は、
「TypeArray」クラスのメソッド（メンバー関数）
「MallocBYTE()」で動的に画像メモリを取得！
「FUN.Clear(pWimg,0);」は、画像画素全体を０クリアと
初期設定する事で次のＬＵＴ変換実行前に０クリアして居る
事を説明の為に示します！
「FUN.Convert(pPatImg,pWimg,pLut);」は、この関数
「Convert()」の説明がココの例文です！そして最初の
ＬＵＴ変換例として先ほど作成したＬＵＴ（pLut）で
元の横（Ｘ座標）方向インクリメント・パターン画像を
ここのＬＵＴ（pLut）で変換し、結果画像を「pWimg」で示
す結果画像を作成します！初期設定で０クリアして居るので
ＬＵＴ変換を実行したら、０クリア画像と異なる事が分かる
でしょう！と言う事で分かる為に
「FUN.WriteBitmap("testFile6.bmp",pWimg);」は、
ＬＵＴ変換結果画像「pWimg」を
ファイル名「"testFile6.bmp"」でＢＭＰ形式の画像ファイ
ル作成！
典型的な２値化画像生成方法での処理：
サンプルパターン画像作成
// 典型的な２値化画像生成方法での処理
// サンプルパターン画像作成
FUN.Clear( pPatImg, 100 ); // 画像メモリ「画素データ100でクリア」
pimgA->subset( pPatImg, 100, 200, // 座標範囲（100,200）⇒（149,229）の範囲の
50, 30 ); // 部分画像を用意
FUN.Clear( pimgA, 200 ); // 部分画像を画素データ200でクリア
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile7.bmp", pPatImg );「FUN.Clear(pPatImg,100);」は、画像画素全体を画素の
数値「100」≪黒（0）より明るく白（255）より暗い輝度
画素≫でクリア！
「pimgA->subset(pPatImg,100,200,50,30);」は、パターン
画像の部分画像とし座標範囲「(100,200)・・(149,29)」の
部分画像とし「pimgA」をセットします！そして
「FUN.Clear(pimgA,200);」は、その部分画像「pimgA」画素
全体を画素の数値「200」≪pPatImgの輝度（100）より明る
く白（255）より暗い輝度画素≫でクリア！
「FUN.WriteBitmap("testFile7.bmp",pPatImg);」は、
ファイル名「"testFile7.bmp"」で今回のサンプル画像
パターンをＢＭＰ形式の画像ファイル作成！
典型的な２値化しきい値を算出する方法
// 典型的な２値化しきい値を算出する方法
FUN.HistogramImage( pPatImg, hgm ); // 画像の画素濃度ヒストグラム産出
t = FUN.GetBinOotu( hgm, 256 ); // 大津法と言う画像処理で一般的な産出手法で
// 濃度ヒストグラム・データから、しきい値産出ここでは、画像認識処理典型的な方式≪ビデオカメラで撮影
した画像【★説明を簡単にする為に画素がモノクロ（白黒）
輝度濃淡画像を撮影した事で説明★】を１バイト（８ビット
）画素の画像メモリに格納後⇒異物混入検査とし２値化処理
を行う典型的な手順を説明≫として濃度ヒストグラムを画像
から算出し、その統計学的な方式≪ヒストグラム＝度数分布
グラフを意味します「量的データの分布の様子を見るのに用
いられます。データをいくつかの階級に分け、度数分布表を
作成してからグラフを作成」と統計学で使用される手法です
が、これで分布が低い（画素の値が小さい）塊と高い（画素
の値が大きい）塊に分けられると言う依り、二つに分けるの
に都合の良い「しきい値」を作成して、その「しきい値」で
高低に分ける事です！≫⇒ＡＤＳ社の画像処理装置ＩＰ－４
は、使用頻度が高いと考えてハードウェアでリアルタイム（
アナログ放送カメラ速度で１画面撮影時間≒１／３０秒）で
「しきい値」を算出する機構を特別にオプションボードとし
販売し、その制御プログラムを私は作成して居ましたので、
画像処理ライブラリにも独立した
クラス「Ｈｉｓｔｏｇｒａｍ」を分離して用意したと別の
解説クラスＨｉｓｔｏｇｒａｍ（××）』で解説して行きま
すので少し、後の説明順に成るので「典型的な使用方法」だ
け紹介します！
「FUN.HistogramImage(pPatImg,hgm);」は、ヒストグラム
算出関数「HistogramImage()」で画像「pPatImg」を処理し
結果データを「long hgm[256];」とサイズ「256」の配列に
格納≪１バイト（８ビット）画素が対象なので画素の値が
「0..255」と２５６種類しか度数分布データで無いからで、
更に「long型」でデータ配列を使うのは、例えば、大きな
画像４Ｋ「４０９６×４０９６画素数＝１６７７７２１６」
と大きな数に成るので頻度なので最大の値は画像のサイズに
匹敵するから大きなサイズが格納出来る事が必要なので
「long型」を使用≫、そして算出したヒストグラムデータ
から「大昔の画像処理ライブラリ（フォートランで記述した
画像処理定番のスパイダーと呼ばれるソースコードから定番
処理の大津法『恐らく開発した学者・技術者の名前と思える
』）」の大津法が、私の応用として各種の工場等の検査装置
に使用でも定番中の定番として上手く行った２値化技法なの
でコノ大津法を紹介？！
「t=FUN.GetBinOotu(hgm,256);」は、大津法で２値化
しきい値をヒストグラムデータ「hgm」から算出します！
ＬＵＴ変換サンプル：２値化
//ＬＵＴ変換サンプル：２値化
FUN.up_fill( 0, lut, t ); // ＬＵＴ配列の「0..t」を０クリアし
FUN.up_fill( 255, &lut[t], 256 - t ); // 「t..255」迄を２５５で書き込む事で
// ２値化ＬＵＴパターン作成
FUN.Convert( pPatImg, pWimg, pLut ); // 今回紹介する関数「Convert()」でＬＵＴ変換
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile8.bmp", pWimg );「FUN.up_fill(0,lut,t);」は、２値化しきい値「t」までの
値でＬＵＴ変換用のＬＵＴ「BYTE lut[256];」の下位を
値「0」にして
「FUN.up_fill(255,&lut[t],256-t);」は、上位を値「255」
にＬＵＴ２値化変換パターンを作成し、
「FUN.Convert(pPatImg,pWimg,pLut);」は、２値化変換を
行います！そして
「FUN.WriteBitmap("testFile8.bmp",pWimg);」は、
ＬＵＴ変換結果画像「pWimg」を
ファイル名「"testFile8.bmp"」でＢＭＰ形式の画像ファイ
ル作成！
後始末
// 後始末
pPatImg->freeMem(); // 画像メモリ解放
pWimg->freeMem(); // 画像メモリ解放「pPatImg->freeMem(); 」は、パターン画像動的メモリ取得
したのでメモリ解放
「pWimg->freeMem();」は、ＬＵＴ変換後の結果画像動的
メモリ取得したのでメモリ解放
★注意★
上記例文で注意して欲しいのは、ＬＵＴ１次元配列「plut」
には「->freeMem()」でメモリを解放シナイ事です！
お判りと思いますが、「pLut->SetBYTE ()」と「lut[]」の
実メモリをセットしているのでメモリ取得は「pPatImg」と
「pWimg」の画像メモリは行い！一次元配列「pLut」は、
メモリ取得を行ってイナイので取得して無いメモリを開放
するとシステムが変に成る事を考えて欲しい？！
作成した画像ファイル
★注意★
本当は、ソースコードを実行して作れば、カクカクした階段
増加で無く滑らかなグラデーション諧調に成るのですが、
私が、ド貧乏人に成り、無料コンパイラも使用期限を越えて
プログラムを動作出来る環境が有りませんので仕方ないので
描画ソフト「ペイント」で手作業で作成した物ですが、
滑らかなグラデーション諧調の画像と考えて下さい！
尚、解説『投げ銭方式ライブラリのダウンロード』での
有料（投げ銭）まで読んで頂ければ、私に開発環境を恵んで
頂く費用を出す事に成ります！出来たら、開発環境の費用を
お恵み下さい！
取り敢えず、本日（３月１８）の講義は、ココまでにし
ます！何だか、疲れたのだ！受講されている方も、お疲れと
思いますのでココまでとします！
まだ、Ｎｏｔｅサーバーが快適に動く分量ですから、
引き続き、この文章に続きは、載せます！
２０２４年３月１９続講
（４－１４－８）関数「int ConvertByte(TypeArray* ps,
TypeArray* pd,BYTE *lut){・・・｝」の説明
int CopyClear::ConvertByte(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
BYTE *lut // ＬＵＴポインタ
){
TypeArray s; // Ｓ：サイズ補正後
TypeArray d; // Ｄ：サイズ補正後
int ws; // Ｓ配列の単位幅
int hv; // 水平／垂直幅
ws = ps->w; // 単位幅取出し：Ｓ
if( ws < 1 || ws > 2 ){ // Ｓが１か２Byte以
return( STI_ARY_5 - 10 ); // 外は左記を返す
} //
s = *ps; // Ｓ配列を補正する
ps = &s; // ため情報をコピー
d = *pd; // Ｄ配列を補正する
pd = &d; // ため情報をコピー
hv = ( ps->h < pd->h ) ? ps->h : pd->h; // 水平幅を最小で
ps->h = hv; // 補正
pd->h = hv; //
hv = ( ps->v < pd->v ) ? ps->v : pd->v; // 垂直幅を最小で
ps->v = hv; // 補正
pd->v = hv; //
if( ws == 1 ){ // Ｓが１Byte整数時
return( cvt_byte_b( ps, pd, lut ) ); // 左記で LUT変換
}else{ // Ｓが２Byte整数時
return( cvt_byte_w( ps, pd, lut ) ); // 左記で LUT変換
} //
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（４－１４－８－Ａ）関数「int ConvertByte()」の【関数名】説明
「Convert」は、英単語「Convert」として変換するの意味で
す！ここの画像処理では、ＬＵＴ≪ルックアップテーブル≫
を使用したＳ（元）画像⇒ＬＵＴ変換⇒Ｄ（結果）画像への
画素データをＬＵＴ≪Lookuptable≫として一時的に変換す
る技法を使用して変換する関数です！
「BYTE 」は、勿論、「BYTE型」と画素の単位が１バイト
無符号を示し、結果画像が「BYTE型」に成る変換関数です！
（４－１４－８－Ｂ）関数「int ConvertByte()」の【返値】説明
int CopyClear::ConvertByte(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
BYTE *lut // ＬＵＴポインタ
){この関数自体でエラーチェックするのは、
仮引数「TypeArray* ps,」詰り、Ｓ画像画素単位が、
１バイトか２バイト単位で無ければ、
エラー「STI_ARY_5-10」と最初の「TypeArray* 」に問題が
有った事を示し、後は、サブルーチンの
「cvt_byte_b(ps,pd,lut)」及び「cvt_byte_w(ps,pd,lut)」
で値を返します！
（４－１４－８－Ｃ）関数「int ConvertByte()」の【仮引数】説明
int CopyClear::ConvertByte(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
BYTE *lut // ＬＵＴポインタ
){「TypeArray* ps,」は、Ｓ（元）画像情報へのポインタを
意味します！
「TypeArray* pd,」は、Ｄ（結果）画像情報へのポインタを
意味します！
「BYTE *lut」は、ＬＵＴの実体へのポインタとして、この
関数では「BYTE *」型、詰り符号無し１バイト単位です！
★注意★
ＬＵＴのサイズは、指定しませんが、暗黙の了解として
Ｓ（元）画像が、１バイト単位画素なら「２５６」バイト
用意しているし、２バイト単位画素なら「画素データ最大値
」まで用意して居る事が前提条件です！
（４－１４－８－Ｄ）関数「int ConvertByte()」の【アルゴリズム】説明
){
TypeArray s; // Ｓ：サイズ補正後
TypeArray d; // Ｄ：サイズ補正後
int ws; // Ｓ配列の単位幅
int hv; // 水平／垂直幅
ws = ps->w; // 単位幅取出し：Ｓ
if( ws < 1 || ws > 2 ){ // Ｓが１か２Byte以
return( STI_ARY_5 - 10 ); // 外は左記を返す
} //
s = *ps; // Ｓ配列を補正する
ps = &s; // ため情報をコピー
d = *pd; // Ｄ配列を補正する
pd = &d; // ため情報をコピー
hv = ( ps->h < pd->h ) ? ps->h : pd->h; // 水平幅を最小で
ps->h = hv; // 補正
pd->h = hv; //
hv = ( ps->v < pd->v ) ? ps->v : pd->v; // 垂直幅を最小で
ps->v = hv; // 補正
pd->v = hv; //
if( ws == 1 ){ // Ｓが１Byte整数時
return( cvt_byte_b( ps, pd, lut ) ); // 左記で LUT変換
}else{ // Ｓが２Byte整数時
return( cvt_byte_w( ps, pd, lut ) ); // 左記で LUT変換
} //
}ローカル変数
){
TypeArray s; // Ｓ：サイズ補正後
TypeArray d; // Ｄ：サイズ補正後
int ws; // Ｓ配列の単位幅
int hv; // 水平／垂直幅「TypeArray s;」は、有効範囲サイズ補正用のＳ画像情報
「TypeArray d;」は、有効範囲サイズ補正用のＤ画像情報
「int ws;」は、Ｓ画像の画素単位を扱い易くした変数
「int hv;」は、仮引数「TypeArray* ps,TypeArray* pd」
の水平幅／垂直幅の最小値（ＳＤ両者の有効幅）算出用です
アルゴリズムコード
ws = ps->w; // 単位幅取出し：Ｓ
if( ws < 1 || ws > 2 ){ // Ｓが１か２Byte以
return( STI_ARY_5 - 10 ); // 外は左記を返す
} //
s = *ps; // Ｓ配列を補正する
ps = &s; // ため情報をコピー
d = *pd; // Ｄ配列を補正する
pd = &d; // ため情報をコピー
hv = ( ps->h < pd->h ) ? ps->h : pd->h; // 水平幅を最小で
ps->h = hv; // 補正
pd->h = hv; //
hv = ( ps->v < pd->v ) ? ps->v : pd->v; // 垂直幅を最小で
ps->v = hv; // 補正
pd->v = hv; //
if( ws == 1 ){ // Ｓが１Byte整数時
return( cvt_byte_b( ps, pd, lut ) ); // 左記で LUT変換
}else{ // Ｓが２Byte整数時
return( cvt_byte_w( ps, pd, lut ) ); // 左記で LUT変換
} //
}「ws=ps->w;」は、Ｓ画像単位幅を扱い易く取り出し！
「if(ws<1||ws>2){return(STI_ARY_5-10);}」は、
条件「(ws<1||ws>2)」、詰り、Ｓ画像画素単位が、
１バイトか２バイト単位で無ければ、エラーとして
「STI_ARY_5-10」と最初の仮引数「TypeArray* ps,」が
エラーを起こしたと間数値を返し関数終了！
「s=*ps;ps=&s;d=*pd;pd=&d;」は、ＳＤ両者の画像情報を
ローカル変数に一旦、移し、有効幅に補正する準備！
「hv=(ps->h<pd->h)?ps->h:pd->h;」は、水平幅の有効幅（
ＳＤ両者の最小値）を算出ト！
「ps->h=hv;pd->h=hv;」は、ＳＤ両者の水平幅を補正！
「hv=(ps->v<pd->v)?ps->v:pd->v;ps->v=hv;pd->v=hv;」
は、ＳＤ両者の垂直幅を算出し両者を補正！
「if(ws==1){・・成立・・}else{・・非成立}」は、
条件「(ws==1)」詰り、Ｓ画像が１バイト単位ならば、
成立「return(cvt_byte_b(ps,pd,lut));」とサブルーチン
「cvt_byte_b(ps,pd,lut)」で処理し、関数返値もサブルー
チンの値を返し関数終了！
「}else{」と非成立「return(cvt_byte_w(ps,pd,lut));}」
でサブルーチン「cvt_byte_w(ps,pd,lut)」で処理し、
関数返値もサブルーチンの値を返し関数終了！
（４－１４－８－Ｅ）関数「int ConvertByte(」の【使用例】説明
{
TypeArray PatImg; // 画像型変数
// ：編か前のパターン画像
TypeArray* pPatImg=&PatImg; // 上記へのポインタ
TypeArray Wimg; // 画像型変数
//：フィル書き込み用
TypeArray* pWimg=&Wimg; // 上記へのポインタ
//：部分画像用
TypeArray* pimgA=&PatImg; // 部分画像用
TypeArray* pimgB=&PatImg; // 部分画像用
BYTE lut[256]; // ＬＵＴ実体
long hgm[256]; // ヒストグラム算出データ配列
BYTE* p; // 画像画素へのポインタ
int i; // ループカウンタ
int j; // ループカウンタ
int x; // Ｘ座標
int y; // Ｙ座標
int d; // 画素データ
int t; // ２値化しきい値
int sti; // ステータス情報
pPatImg->MallocBYTE( 640, 480 ); // サイズ６４０×４８０画像メモリ取得
FUN.Clear( pPatImg, 0 ); // 画像メモリ「０クリア」
p = pPatImg->getPtrByte( 0, 0 ); //
for( x = 0; x < 640; x++ ){ //
d = x & 0x0ff; // 0..255の値にする
*p++ = d; // 画素として書き込む
} // １行分パターン画像作成
pimgA->subset( pPatImg, 0, 0, 640, 1 ); // 先頭行の部分画像
for( y = 1; y < 480; y++ ){ //
pimgB->subset( pPatImg, 0, y, 640, // ２行以降の任意場所の
1 ); // 部分画像
FUN.Copy( pimgA, pimgB ); // 先頭行のパターン画像を２行目以降にコピー
} // これで横方向インクリメントパターン画像作成
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap( "testFile5.bmp", pPatImg );
//ＬＵＴ変換サンプル：画素データ反転
for( i = 0; i < 256; i++ ){ // 極、普通の教科書的な記載でlut[0..255]の中の
lut[i] = 255 - i; // パターンが「255..0」と８ビット内データで
} // 反転している事が分かるでしょう！
pWimg->MallocBYTE( 640, 480 ); // サイズ６４０×４８０画像メモリ取得
FUN.Clear( pWimg, 0 ); // 画像メモリ「０クリア」
FUN.ConvertByte( pPatImg, pWimg, lut ); // 今回紹介する関数「ConvertByte()」でＬＵＴ変換
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile6.bmp", pWimg );
// 典型的な２値化画像生成方法での処理
// サンプルパターン画像作成
FUN.Clear( pPatImg, 100 ); // 画像メモリ「画素データ100でクリア」
pimgA->subset( pPatImg, 100, 200, // 座標範囲（100,200）⇒（149,229）の範囲の
50, 30 ); // 部分画像を用意
FUN.Clear( pimgA, 200 ); // 部分画像を画素データ200でクリア
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile7.bmp", pPatImg );
// 典型的な２値化しきい値を算出する方法
FUN.HistogramImage( pPatImg, hgm ); // 画像の画素濃度ヒストグラム産出
t = FUN.GetBinOotu( hgm, 256 ); // 大津法と言う画像処理で一般的な産出手法で
// 濃度ヒストグラム・データから、しきい値産出
//ＬＵＴ変換サンプル：２値化
FUN.up_fill( 0, lut, t ); // ＬＵＴ配列の「0..t」を０クリアし
FUN.up_fill( 255, &lut[t], 256 - t ); // 「t..255」迄を２５５で書き込む事で
// ２値化ＬＵＴパターン作成
FUN.ConvertByte( pPatImg, pWimg, lut ); // 今回紹介する関数「ConvertByte()」でＬＵＴ変換
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile8.bmp", pWimg );
// 後始末
pPatImg->freeMem(); // 画像メモリ解放
pWimg->freeMem(); // 画像メモリ解放
}★注意★
上記例文で注意して欲しいのは、ＬＵＴ一次元配列「lut[]」
と直接、Ｃ言語表現での実テーブルを使用して居る事です！
場合に依っては、関数「int Convert()」を使用した場合
より効率的に成る為にコノ関数が用意された事が分かる
でしょう！
☆備考☆
関数「int Convert()」・「int ConvertByte()」も実際に
サブルーチンの奥では同じ関数で実際の処理は行い！
関数を呼び出す形式が必要に応じて選べる様にしています！
（４－１４－９）関数「int ConvertWord(
TypeArray* ps,TypeArray* pd,
short *lut){・・・｝」の説明
int CopyClear::ConvertWord(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
short *lut // ＬＵＴポインタ
){
TypeArray s; // Ｓ：サイズ補正後
TypeArray d; // Ｄ：サイズ補正後
int ws; // Ｓ配列の単位幅
int hv; // 水平／垂直幅
ws = ps->w; // 単位幅取出し：Ｓ
if( ws < 1 || ws > 2 ){ // Ｓが１か２Byte以
return( STI_ARY_5 - 10 ); // 外は左記を返す
} //
s = *ps; // Ｓ配列を補正する
ps = &s; // ため情報をコピー
d = *pd; // Ｄ配列を補正する
pd = &d; // ため情報をコピー
hv = ( ps->h < pd->h ) ? ps->h : pd->h; // 水平幅を最小で
ps->h = hv; // 補正
pd->h = hv; //
hv = ( ps->v < pd->v ) ? ps->v : pd->v; // 垂直幅を最小で
ps->v = hv; // 補正
pd->v = hv; //
if( ws == 1 ){ // Ｓが１Byte整数時
return( cvt_word_b( ps, pd, lut ) ); // 左記で LUT変換
}else{ // Ｓが２Byte整数時
return( cvt_word_w( ps, pd, lut ) ); // 左記で LUT変換
} //
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（４－１４－９－Ａ）関数「int ConvertWord()」の【関数名】説明
「Convert」は、英単語「Convert」として変換するの意味で
す！ここの画像処理では、ＬＵＴ≪ルックアップテーブル≫
を使用したＳ（元）画像⇒ＬＵＴ変換⇒Ｄ（結果）画像への
画素データをＬＵＴ≪Lookuptable≫として一時的に変換す
る技法を使用して変換する関数です！
「Word」は、勿論、「short型」と画素の単位が２バイトを
示し、結果画素が「２バイト」に成る変換関数です！
（４－１４－９－Ｂ）関数「int ConvertWord()」の【返値】説明
int CopyClear::ConvertWord(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
short *lut // ＬＵＴポインタ
){この関数自体でエラーチェックするのは、
仮引数「TypeArray* ps,」詰り、Ｓ画像画素単位が、
１バイトか２バイト単位で無ければ、
エラー「STI_ARY_5-10」と最初の「TypeArray* 」に問題が
有った事を示し、後は、サブルーチンの
「cvt_word_b(ps,pd,lut)」及び「cvt_word_w(ps,pd,lut)」
で値を返します！
（４－１４－９－Ｃ）関数「int ConvertWord()」の【仮引数】説明
int CopyClear::ConvertWord(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
short *lut // ＬＵＴポインタ
){「TypeArray* ps,」は、Ｓ（元）画像情報へのポインタを
意味します！
「TypeArray* pd,」は、Ｄ（結果）画像情報へのポインタを
意味します！
「short *lut」は、ＬＵＴの実体へのポインタとして、この
関数では「short *」型、詰り２バイト単位です！
（４－１４－９－Ｄ）関数「int ConvertWord()」の【アルゴリズム】説明
){
TypeArray s; // Ｓ：サイズ補正後
TypeArray d; // Ｄ：サイズ補正後
int ws; // Ｓ配列の単位幅
int hv; // 水平／垂直幅
ws = ps->w; // 単位幅取出し：Ｓ
if( ws < 1 || ws > 2 ){ // Ｓが１か２Byte以
return( STI_ARY_5 - 10 ); // 外は左記を返す
} //
s = *ps; // Ｓ配列を補正する
ps = &s; // ため情報をコピー
d = *pd; // Ｄ配列を補正する
pd = &d; // ため情報をコピー
hv = ( ps->h < pd->h ) ? ps->h : pd->h; // 水平幅を最小で
ps->h = hv; // 補正
pd->h = hv; //
hv = ( ps->v < pd->v ) ? ps->v : pd->v; // 垂直幅を最小で
ps->v = hv; // 補正
pd->v = hv; //
if( ws == 1 ){ // Ｓが１Byte整数時
return( cvt_word_b( ps, pd, lut ) ); // 左記で LUT変換
}else{ // Ｓが２Byte整数時
return( cvt_word_w( ps, pd, lut ) ); // 左記で LUT変換
} //
}ローカル変数
){
TypeArray s; // Ｓ：サイズ補正後
TypeArray d; // Ｄ：サイズ補正後
int ws; // Ｓ配列の単位幅
int hv; // 水平／垂直幅「TypeArray s;」は、有効範囲サイズ補正用のＳ画像情報
「TypeArray d;」は、有効範囲サイズ補正用のＤ画像情報
「int ws;」は、Ｓ画像の画素単位を扱い易くした変数
「int hv;」は、仮引数「TypeArray* ps,TypeArray* pd」
の水平幅／垂直幅の最小値（ＳＤ両者の有効幅）算出用です
アルゴリズムコード
ws = ps->w; // 単位幅取出し：Ｓ
if( ws < 1 || ws > 2 ){ // Ｓが１か２Byte以
return( STI_ARY_5 - 10 ); // 外は左記を返す
} //
s = *ps; // Ｓ配列を補正する
ps = &s; // ため情報をコピー
d = *pd; // Ｄ配列を補正する
pd = &d; // ため情報をコピー
hv = ( ps->h < pd->h ) ? ps->h : pd->h; // 水平幅を最小で
ps->h = hv; // 補正
pd->h = hv; //
hv = ( ps->v < pd->v ) ? ps->v : pd->v; // 垂直幅を最小で
ps->v = hv; // 補正
pd->v = hv; //
if( ws == 1 ){ // Ｓが１Byte整数時
return( cvt_word_b( ps, pd, lut ) ); // 左記で LUT変換
}else{ // Ｓが２Byte整数時
return( cvt_word_w( ps, pd, lut ) ); // 左記で LUT変換
} //
}「ws=ps->w;」は、Ｓ画像単位幅を扱い易く取り出し！
「if(ws<1||ws>2){return(STI_ARY_5-10);}」は、
条件「(ws<1||ws>2)」、詰り、Ｓ画像画素単位が、
１バイトか２バイト単位で無ければ、エラーとして
「STI_ARY_5-10」と最初の仮引数「TypeArray* ps,」が
エラーを起こしたと間数値を返し関数終了！
「s=*ps;ps=&s;d=*pd;pd=&d;」は、ＳＤ両者の画像情報を
ローカル変数に一旦、移し、有効幅に補正する準備！
「hv=(ps->h<pd->h)?ps->h:pd->h;」は、水平幅の有効幅（
ＳＤ両者の最小値）を算出ト！
「ps->h=hv;pd->h=hv;」は、ＳＤ両者の水平幅を補正！
「hv=(ps->v<pd->v)?ps->v:pd->v;ps->v=hv;pd->v=hv;」
は、ＳＤ両者の垂直幅を算出し両者を補正！
「if(ws==1){・・成立・・}else{・・非成立}」は、
条件「(ws==1)」詰り、Ｓ画像が１バイト単位ならば、
成立「return(cvt_word_b(ps,pd,lut));」とサブルーチン
「cvt_word_b(ps,pd,lut)」で処理し、関数返値もサブルー
チンの値を返し関数終了！
「}else{」と非成立「return(cvt_word_w(ps,pd,lut));}」
でサブルーチン「cvt_word_w(ps,pd,lut)」で処理し、
関数返値もサブルーチンの値を返し関数終了！
（４－１４－９－Ｅ）関数「int ConvertWord(」の【使用例】説明
{
TypeArray PatImg; // 画像型変数
// ：編か前のパターン画像
TypeArray* pPatImg=&PatImg; // 上記へのポインタ
TypeArray Wimg; // 画像型変数
//：フィル書き込み用
TypeArray* pWimg=&Wimg; // 上記へのポインタ
//：部分画像用
TypeArray* pimgA=&PatImg; // 部分画像用
TypeArray* pimgB=&PatImg; // 部分画像用
short lut[256]; // ＬＵＴ実体
long hgm[256]; // ヒストグラム算出データ配列
short* p; // 画像画素へのポインタ
int i; // ループカウンタ
int j; // ループカウンタ
int x; // Ｘ座標
int y; // Ｙ座標
int d; // 画素データ
int t; // ２値化しきい値
int sti; // ステータス情報
pPatImg->MallocShort( 640, 480 ); // サイズ６４０×４８０画像メモリ取得
FUN.Clear( pPatImg, 0 ); // 画像メモリ「０クリア」
p = pPatImg->getPtrShort( 0, 0 ); //
for( x = 0; x < 640; x++ ){ //
d = x; // 0..639の値にする
*p++ = d; // 画素として書き込む
} // １行分パターン画像作成
pimgA->subset( pPatImg, 0, 0, 640, 1 ); // 先頭行の部分画像
for( y = 1; y < 480; y++ ){ //
pimgB->subset( pPatImg, 0, y, 640, // ２行以降の任意場所の
1 ); // 部分画像
FUN.Copy( pimgA, pimgB ); // 先頭行のパターン画像を２行目以降にコピー
} // これで横方向インクリメントパターン画像作成
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap( "testFile5.bmp", pPatImg );
//ＬＵＴ変換サンプル：画素データ反転
for( i = 0; i < 256; i++ ){ // 極、普通の教科書的な記載でlut[0..255]の中の
lut[i] = 255 - i; // パターンが「255..0」と８ビット内データで
} // 反転している事が分かるでしょう！
pWimg->MallocBYTE( 640, 480 ); // サイズ６４０×４８０画像メモリ取得
FUN.Clear( pWimg, 0 ); // 画像メモリ「０クリア」
FUN.Convertshort( pPatImg, pWimg, lut );// 今回紹介する関数「Convertshort()」でＬＵＴ変換
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile6.bmp", pWimg );
// 典型的な２値化画像生成方法での処理
// サンプルパターン画像作成
FUN.Clear( pPatImg, 100 ); // 画像メモリ「画素データ100でクリア」
pimgA->subset( pPatImg, 100, 200, // 座標範囲（100,200）⇒（149,229）の範囲の
50, 30 ); // 部分画像を用意
FUN.Clear( pimgA, 200 ); // 部分画像を画素データ200でクリア
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile7.bmp", pPatImg );
// 典型的な２値化しきい値を算出する方法
FUN.HistogramImage( pPatImg, hgm ); // 画像の画素濃度ヒストグラム産出
t = FUN.GetBinOotu( hgm, 256 ); // 大津法と言う画像処理で一般的な産出手法で
// 濃度ヒストグラム・データから、しきい値産出
//ＬＵＴ変換サンプル：２値化
FUN.up_fill( 0, lut, t ); // ＬＵＴ配列の「0..t」を０クリアし
FUN.up_fill( 255, &lut[t], 256 - t ); // 「t..255」迄を２５５で書き込む事で
// ２値化ＬＵＴパターン作成
FUN.Convertshort( pPatImg, pWimg, lut );// 今回紹介する関数「Convertshort()」でＬＵＴ変換
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile8.bmp", pWimg );
// 後始末
pPatImg->freeMem(); // 画像メモリ解放
pWimg->freeMem(); // 画像メモリ解放
}★注意★
上記例文で注意して欲しいのは、ＬＵＴ一次元配列「lut」
と直接、Ｃ言語表現での実テーブルを使用して居る事です！
場合に依っては、関数「int Convert()」を使用した場合
より効率的に成る為にコノ関数が用意された事が分かる
でしょう！
☆備考☆
関数「int Convert()」・「int ConvertWord()」も実際に
サブルーチンの奥では同じ関数で実際の処理は行い！
関数を呼び出す形式が必要に応じて選べる様にしています！
★補足★
通常、良く使用される撮像用のデジタルカメラの輝度濃度
データは、１バイト（８ビット＝0：黒⇒255：白）ですが、
特殊用途で更にダイナミックレンジが広い特殊カメラ≪安定
撮影サセル為にペルチェ素子＋水冷冷却システムと多少高価
なカメラも存在し、使用経験が有るものは英国アンドリュー
のカメラで画素データが２バイト（１０ビット＝0：黒⇒
1023：白）も存在します≫、コノ様なカメラの映像も加工
出来る為に元画像が、８ビットを越えた例として例文サンプ
ル作成しました！
取り敢えず、本日（３月１９）の講義は、ココまでにし
ます！何だか、疲れたのだ！受講されている方もお疲れと
思いますのでココまでとします！
まだ、Ｎｏｔｅサーバーが快適に動く分量ですから、
引き続き、この文章に続きは、載せます！
２０２４年３月２０続講
（４－１４－１０）関数「int ConvertLine(
TypeArray* ps,TypeArray* pd,
BYTE tbl[],int mode){・・・｝」の説明
int CopyClear::ConvertLine(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列
BYTE tbl[], // テーブル「1..255」
int mode // 0→水平方向,1→垂直方向
){
BYTE* lut; // ＬＵＴバッファー
TypeArray subS; // 部分画像Ｓ
TypeArray subD; // 部分画像Ｄ
int h; // 水平幅
int v; // 垂直幅
int k; // 割合（255に対して）
int x; // Ｘ座標
int x0; // Ｘ座標：始点
int x1; // Ｘ座標：終点
int y; // Ｙ座標
int y0; // Ｙ座標：始点
int y1; // Ｙ座標：終点
int sti; // ステータス情報
sti = CheckImageByte( ps ); // 元画像検査
if( sti != END_STI ){ // 不正が有れば
return( sti ); // エラーステータスを返す
} //
sti = CheckImageByte( pd ); // 結果画像検査
if( sti != END_STI ){ // 不正が有れば
return( sti ); // エラーステータスを返す
} //
h = ( ps->h < pd->h ) ? ps->h : pd->h; // 有効水平幅算出
v = ( ps->v < pd->v ) ? ps->v : pd->v; // 有効垂直幅算出
if( mode == 0 ){ // 水平方向なら
lut = (BYTE*)malloc( sizeof(BYTE) * 256 * h ); // LUTを256*水平幅で確保
if( lut != 0 ){ // 確保成功時は
sti = makeCvtLineLUT( lut, tbl, h ); // 左記でＬＵＴ作成
if( sti != END_STI ){ // 不正が有れば
free( lut ); // ＬＵＴを解放
return( sti ); // エラーステータスを返す
} //
convertLineX( ps, pd, lut ); // 水平方向ＬＵＴ変換
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
} //
}else{ // 垂直方向なら
lut = (BYTE*)malloc( sizeof(BYTE) * 256 * v ); // LUTを256*垂直幅で確保
if( lut != 0 ){ // 確保成功時は
sti = makeCvtLineLUT( lut, tbl, v ); // 左記でＬＵＴ作成
if( sti != END_STI ){ // 不正が有れば
free( lut ); // ＬＵＴを解放
return( sti ); // エラーステータスを返す
} //
convertLineY( ps, pd, lut ); // 垂直方向ＬＵＴ変換
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
} //
} // ※大規模LUT確保失敗時の処理※
lut = (BYTE*)malloc( sizeof(BYTE) * 256 ); // LUTを256で確保
if( lut == 0 ){ // 確保失敗時は
return( STI_MEM ); // 左記を返す
} //
if( mode == 0 ){ // 水平方向なら
x0 = 0; // Ｘ座標：始点セット
k = tbl[x0]; // 先頭の割合取り出し
for( x = 1; x < h; x++ ){ // Ｘ座標を繰り返し
if( k != tbl[x] ){ // 同一割合で無くなれば
x1 = x - 1; // Ｘ座標：終点セット
makeCvtLineLUTSingle( lut, k ); // 左記でＬＵＴ作成
subS.subset( ps, x0, 0, x1 - x0 + 1, v ); // 部分画像Ｓセット
subD.subset( pd, x0, 0, x1 - x0 + 1, v ); // 部分画像Ｄセット
ConvertByte( &subS, &subD, lut ); // ＬＵＴ変換
x0 = x; // Ｘ座標：始点更新
k = tbl[x0]; // 割合更新
} //
} //
}else{ // 垂直方向なら
y0 = 0; // Ｙ座標：始点セット
k = tbl[y0]; // 先頭の割合取り出し
for( y = 1; y < v; y++ ){ // Ｙ座標を繰り返し
if( k != tbl[y] ){ // 同一割合で無くなれば
y1 = y - 1; // Ｙ座標：終点セット
makeCvtLineLUTSingle( lut, k ); // 左記でＬＵＴ作成
subS.subset( ps, 0, y0, h, y1 - y0 + 1 ); // 部分画像Ｓセット
subD.subset( pd, 0, y0, h, y1 - y0 + 1 ); // 部分画像Ｄセット
ConvertByte( &subS, &subD, lut ); // ＬＵＴ変換
y0 = y; // Ｙ座標：始点更新
k = tbl[y0]; // 割合更新
} //
} //
} //
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「public:」属性ですので
ライブラリの外から使用可能です！
（４－１４－１０－Ａ）関数「int ConvertLine()」の【関数名】説明
「Convert」は、英単語「Convert」として変換するの意味で
す！ここの画像処理では、ＬＵＴ≪ルックアップテーブル≫
を使用したＳ（元）画像⇒ＬＵＴ変換⇒Ｄ（結果）画像への
画素データをＬＵＴ≪Lookuptable≫として一時的に変換す
る技法を使用して変換する関数ですが、
「Line」は、ココでは、線形（一次元的）に変換⇒元の撮影
画像が照明の関係で傾いている場合に補正を加える処理です
☆備考☆
この関数が何故、存在するかを解説して居る時に思い出した
撮影条件や、カメラの特性で画像の濃淡に機材固有のズレが
生じてアルゴリズムを工夫して補正する必要が遇ったからと
特殊用途で一般的な処理では有りません！
しかしながら、画像処理では撮影機材の問題は付き物なので
過去に如何に工夫したかが分かる例文として解説して行く事
にします！
★備考★
この関数には、オーバーロード（多重定義）として同じ
関数名で仮引数が異なる関数が存在します！
（４－１４－１０－Ｂ）関数「int ConvertLine()」の【返値】説明
int CopyClear::ConvertLine(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列
BYTE tbl[], // テーブル「1..255」
int mode // 0→水平方向,1→垂直方向
){仮引数「TypeArray* ps,TypeArray* pd,」と
Ｓ（元）画像Ｄ（結果）画像共、
検査関数「CheckImageBYTE ();」で検査で１バイト単位で
有るか無いかを検査し、この関数は、ＳＤ両者が１バイト
単位である事を検査し、エラーが有れば返し終了します！
関数の実行時エラーとしてメモリー確保「lut=(BYTE *)
malloc(sizeof(BYTE )*256);」で変数「lut」が空
ポインタに成ったらエラー「STI_MEM」を返し終了します！
正常に最後まで実行し、正常終了「END_STI」を返し
終了します！
（４－１４－１０－Ｃ）関数「int ConvertLine()」の【仮引数】説明
int CopyClear::ConvertLine(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列
BYTE tbl[], // テーブル「1..255」
int mode // 0→水平方向,1→垂直方向
){「TypeArray* ps,」は、Ｓ（元）画像を示す画像情報！
「TypeArray* pd,」は、Ｄ（結果）画像を示す画像情報！
「BYTE tbl[],」は、変換用のテーブルです！サイズは、
コメントに記載して居る「1..255」では、２５５と誤解
するかも知れませんが２５６です！
「int mode」は、モードで「mode＝0」で水平方向変換処理
「mode＝1」で垂直方向変換処理を示します！
（４－１４－１０－Ｄ）関数「int ConvertLine()」の【アルゴリズム】説明
){
BYTE* lut; // ＬＵＴバッファー
TypeArray subS; // 部分画像Ｓ
TypeArray subD; // 部分画像Ｄ
int h; // 水平幅
int v; // 垂直幅
int k; // 割合（255に対して）
int x; // Ｘ座標
int x0; // Ｘ座標：始点
int x1; // Ｘ座標：終点
int y; // Ｙ座標
int y0; // Ｙ座標：始点
int y1; // Ｙ座標：終点
int sti; // ステータス情報
sti = CheckImageByte( ps ); // 元画像検査
if( sti != END_STI ){ // 不正が有れば
return( sti ); // エラーステータスを返す
} //
sti = CheckImageByte( pd ); // 結果画像検査
if( sti != END_STI ){ // 不正が有れば
return( sti ); // エラーステータスを返す
} //
h = ( ps->h < pd->h ) ? ps->h : pd->h; // 有効水平幅算出
v = ( ps->v < pd->v ) ? ps->v : pd->v; // 有効垂直幅算出
if( mode == 0 ){ // 水平方向なら
lut = (BYTE*)malloc( sizeof(BYTE) * 256 * h ); // LUTを256*水平幅で確保
if( lut != 0 ){ // 確保成功時は
sti = makeCvtLineLUT( lut, tbl, h ); // 左記でＬＵＴ作成
if( sti != END_STI ){ // 不正が有れば
free( lut ); // ＬＵＴを解放
return( sti ); // エラーステータスを返す
} //
convertLineX( ps, pd, lut ); // 水平方向ＬＵＴ変換
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
} //
}else{ // 垂直方向なら
lut = (BYTE*)malloc( sizeof(BYTE) * 256 * v ); // LUTを256*垂直幅で確保
if( lut != 0 ){ // 確保成功時は
sti = makeCvtLineLUT( lut, tbl, v ); // 左記でＬＵＴ作成
if( sti != END_STI ){ // 不正が有れば
free( lut ); // ＬＵＴを解放
return( sti ); // エラーステータスを返す
} //
convertLineY( ps, pd, lut ); // 垂直方向ＬＵＴ変換
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
} //
} // ※大規模LUT確保失敗時の処理※
lut = (BYTE*)malloc( sizeof(BYTE) * 256 ); // LUTを256で確保
if( lut == 0 ){ // 確保失敗時は
return( STI_MEM ); // 左記を返す
} //
if( mode == 0 ){ // 水平方向なら
x0 = 0; // Ｘ座標：始点セット
k = tbl[x0]; // 先頭の割合取り出し
for( x = 1; x < h; x++ ){ // Ｘ座標を繰り返し
if( k != tbl[x] ){ // 同一割合で無くなれば
x1 = x - 1; // Ｘ座標：終点セット
makeCvtLineLUTSingle( lut, k ); // 左記でＬＵＴ作成
subS.subset( ps, x0, 0, x1 - x0 + 1, v ); // 部分画像Ｓセット
subD.subset( pd, x0, 0, x1 - x0 + 1, v ); // 部分画像Ｄセット
ConvertByte( &subS, &subD, lut ); // ＬＵＴ変換
x0 = x; // Ｘ座標：始点更新
k = tbl[x0]; // 割合更新
} //
} //
}else{ // 垂直方向なら
y0 = 0; // Ｙ座標：始点セット
k = tbl[y0]; // 先頭の割合取り出し
for( y = 1; y < v; y++ ){ // Ｙ座標を繰り返し
if( k != tbl[y] ){ // 同一割合で無くなれば
y1 = y - 1; // Ｙ座標：終点セット
makeCvtLineLUTSingle( lut, k ); // 左記でＬＵＴ作成
subS.subset( ps, 0, y0, h, y1 - y0 + 1 ); // 部分画像Ｓセット
subD.subset( pd, 0, y0, h, y1 - y0 + 1 ); // 部分画像Ｄセット
ConvertByte( &subS, &subD, lut ); // ＬＵＴ変換
y0 = y; // Ｙ座標：始点更新
k = tbl[y0]; // 割合更新
} //
} //
} //
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
}ローカル変数
){
BYTE* lut; // ＬＵＴバッファー
TypeArray subS; // 部分画像Ｓ
TypeArray subD; // 部分画像Ｄ
int h; // 水平幅
int v; // 垂直幅
int k; // 割合（255に対して）
int x; // Ｘ座標
int x0; // Ｘ座標：始点
int x1; // Ｘ座標：終点
int y; // Ｙ座標
int y0; // Ｙ座標：始点
int y1; // Ｙ座標：終点
int sti; // ステータス情報「BYTE *lut;」は、内部で使用するＬＵＴです！
「TypeArraysubS;」は、Ｓ画像の部分画像用
「TypeArraysubD;」は、Ｄ画像の部分画像用
「int h;」は、内部でサイズ調整に使用した水平幅
「int v;」は、内部でサイズ調整に使用した垂直幅
「int k;」は、仮引数「BYTE tbl[],」に格納している
係数を内部で扱い易い様に取り出した変数です！
「int x;」は、Ｘ座標の値！
「int x0;」は、Ｘ座標の範囲で始点！
「int x1;」は、Ｘ座標の範囲で終点！
「int y;」は、Ｙ座標の値！
「int y0;」はＹ座標の範囲で始点！、
「int y1;」はＹ座標の範囲で終点！、
「int sti;」は、関数の返値の一次置き場！
アルゴリズムコード
sti = CheckImageByte( ps ); // 元画像検査
if( sti != END_STI ){ // 不正が有れば
return( sti ); // エラーステータスを返す
} //
sti = CheckImageByte( pd ); // 結果画像検査
if( sti != END_STI ){ // 不正が有れば
return( sti ); // エラーステータスを返す
} //
h = ( ps->h < pd->h ) ? ps->h : pd->h; // 有効水平幅算出
v = ( ps->v < pd->v ) ? ps->v : pd->v; // 有効垂直幅算出
if( mode == 0 ){ // 水平方向なら
lut = (BYTE*)malloc( sizeof(BYTE) * 256 * h ); // LUTを256*水平幅で確保
if( lut != 0 ){ // 確保成功時は
sti = makeCvtLineLUT( lut, tbl, h ); // 左記でＬＵＴ作成
if( sti != END_STI ){ // 不正が有れば
free( lut ); // ＬＵＴを解放
return( sti ); // エラーステータスを返す
} //
convertLineX( ps, pd, lut ); // 水平方向ＬＵＴ変換
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
} //
}else{ // 垂直方向なら
lut = (BYTE*)malloc( sizeof(BYTE) * 256 * v ); // LUTを256*垂直幅で確保
if( lut != 0 ){ // 確保成功時は
sti = makeCvtLineLUT( lut, tbl, v ); // 左記でＬＵＴ作成
if( sti != END_STI ){ // 不正が有れば
free( lut ); // ＬＵＴを解放
return( sti ); // エラーステータスを返す
} //
convertLineY( ps, pd, lut ); // 垂直方向ＬＵＴ変換
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
} //
} // ※大規模LUT確保失敗時の処理※
lut = (BYTE*)malloc( sizeof(BYTE) * 256 ); // LUTを256で確保
if( lut == 0 ){ // 確保失敗時は
return( STI_MEM ); // 左記を返す
} //
if( mode == 0 ){ // 水平方向なら
x0 = 0; // Ｘ座標：始点セット
k = tbl[x0]; // 先頭の割合取り出し
for( x = 1; x < h; x++ ){ // Ｘ座標を繰り返し
if( k != tbl[x] ){ // 同一割合で無くなれば
x1 = x - 1; // Ｘ座標：終点セット
makeCvtLineLUTSingle( lut, k ); // 左記でＬＵＴ作成
subS.subset( ps, x0, 0, x1 - x0 + 1, v ); // 部分画像Ｓセット
subD.subset( pd, x0, 0, x1 - x0 + 1, v ); // 部分画像Ｄセット
ConvertByte( &subS, &subD, lut ); // ＬＵＴ変換
x0 = x; // Ｘ座標：始点更新
k = tbl[x0]; // 割合更新
} //
} //
}else{ // 垂直方向なら
y0 = 0; // Ｙ座標：始点セット
k = tbl[y0]; // 先頭の割合取り出し
for( y = 1; y < v; y++ ){ // Ｙ座標を繰り返し
if( k != tbl[y] ){ // 同一割合で無くなれば
y1 = y - 1; // Ｙ座標：終点セット
makeCvtLineLUTSingle( lut, k ); // 左記でＬＵＴ作成
subS.subset( ps, 0, y0, h, y1 - y0 + 1 ); // 部分画像Ｓセット
subD.subset( pd, 0, y0, h, y1 - y0 + 1 ); // 部分画像Ｄセット
ConvertByte( &subS, &subD, lut ); // ＬＵＴ変換
y0 = y; // Ｙ座標：始点更新
k = tbl[y0]; // 割合更新
} //
} //
} //
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
}「sti=CheckImageBYTE (ps);if(sti!=END_STI){
return(sti);}」は、仮引数検査関数
「sti=CheckImageBYTE (ps);」でＳ（元）画像が１バイト
単位画像か如何か検査し、判定「if(sti!=END_STI)」で
異なれば「return(sti);」とエラーを返し関数終了！
「sti=CheckImageBYTE (pd);if(sti!=END_STI){
return(sti);}」は、Ｄ（結果）画像が１バイト検査！
「h=(ps->h<pd->h)?ps->h:pd->h;」は、ＳＤ両者の水平幅
での有効幅（最小幅）算出！
「v=(ps->v<pd->v)?ps->v:pd->v;」は、ＳＤ両者の垂直幅
での有効幅（最小幅）算出！
「if(mode==0){・・成立中身・・}else{
・・否成立中身・・}」は、条件「(mode==0)」と
仮引数「int mode」が、０の場合、成立中身ブロックを
処理し、それ以外の場合、否成立中身ブロックを処理します
先ず、成立中身ブロックは、
「lut=(BYTE *)malloc(sizeof(BYTE )256h);」とメモリ
確保します！確保するサイズは「sizeof(BYTE )256h」と
「sizeof(BYTE )」でBYTE型（勿論、unsignedchar）なので
１に成るのですが★注意★未知のＣＰＵ＆処理系にも対応
する為にワザワザ「sizeof(型名)」の記述を採用しました！
そして「256h」と水平幅×２５６をメモリ取得サイズと
しています！水平幅分１バイト単位のＬＵＴが存在するとの
意味です！そして「if(lut!=0){・・メモリ取得成功時」は、
「sti=makeCvtLineLUT(lut,tbl,h);」で下請けのサブルー
チン「makeCvtLineLUT()」でＬＵＴパターン作成処理し、
「if(sti!=END_STI){free(lut);return(sti);」と
処理失敗「sti!=END_STI」ならば「free(lut);」で取得
したメモリを後始末とし解放し、エラーコード「sti」を
返し関数終了！★注意★エラー時のメモリ解放は必須です！
「convertLineX(ps,pd,lut);free(lut);
return(END_STI);」は、サブルーチン「convertLineX()」で
先ほど作成したＬＵＴを使用してＸ座標方向の傾き校正処理
を行います！そして「free(lut);」で取得したメモリを
後始末とし解放し、関数正常終了！★注意★勿論、正常終了
でもメモリ解放は必須です！
次に、否成立中身ブロックは、
「lut=(BYTE *)malloc(sizeof(BYTE )256v);」とメモリ
確保します！
そして「256v」と垂直幅×２５６をメモリ取得サイズと
しています！
垂直幅分１バイト単位のＬＵＴが存在するとの意味です！
そして「if(lut!=0){・・メモリ取得成功時」は、
「sti=makeCvtLineLUT(lut,tbl,v);」で下請けのサブルー
チン「makeCvtLineLUT()」でＬＵＴパターン作成処理し、
「if(sti!=END_STI){free(lut);return(sti);」と
処理失敗「sti!=END_STI」ならば「free(lut);」で取得
したメモリを後始末とし解放し、エラーコード「sti」を
返し関数終了！
「convertLineY(ps,pd,lut);free(lut);
return(END_STI);」は、サブルーチン「convertLineY()」で
先ほど作成したＬＵＴを使用してＹ座標方向の傾き校正処理
を行います！そして「free(lut);」で取得したメモリを
後始末とし解放し、関数正常終了！
★注意★ココまでで関数の大まかな通常処理の説明は終わり
ですが、「lut=(BYTE *)malloc(sizeof(BYTE )256h);」
及び「lut=(BYTE *)malloc(sizeof(BYTE )256v);」の
メモリ確保
で「if(lut!=0){」と確保成功した場合の処理しか説明して
無い事に注意して下さい！
勿論、大概のシステムでは成功する筈ですのでコレから
説明する部分は、メモリをケチって居るシステムの為の
処理です！詰り、
上記「malloc()」が失敗した場合の処理です！
「lut=(BYTE *)malloc(sizeof(BYTE )*256);」は、
１単位分変換用のＬＵＴをメモリ確保した事を示します！
「if(lut==0){return(STI_MEM);}」は、このサイズでも
確保失敗したらエラー「STI_MEM」を返し関数終了！
そして再び、仮引数「int mode」が、０の場合、成立中身
ブロックを処理し、それ以外の場合、否成立中身ブロックを
処理します
先ず、成立中身ブロックは、
「x0=0;k=tbl[x0];」でＸ座標始点初期化と係数の取り出し
です！
「for(x=1;x<h;x++){・・ループ中身・・}」は、ｆｏｒ
ループ構文で初期化「x=1;」でＸ座標を１からスタートし
条件「x<h;」で「h-1」まで「x++」と一つずつ増やして
ブロックをループします！そのループ中身ブロックで
「if(k!=tbl[x]){・・内側成立中身・・」と条件「
k!=tbl[x]」≪現係数の値がテーブルの係数と異なる場合に
処理する＝同じならば変換する意味が無い≫の場合に成立
中身を実行します！その内側成立中身は、
「x1=x-1;」は、Ｘ座標終点を算出！
「makeCvtLineLUTSingle(lut,k);」で基本単位のＬＵＴを
作成して置きます！
「subS.subset(ps,x0,0,x1-x0+1,v);
subD.subset(pd,x0,0,x1-x0+1,v);」でＳＤ両者の処理する
部分画像を「subS・subD」に取り出します！
「ConvertByte(&subS,&subD,lut);」でサブルーチンとし
て関数「ConvertByte();」で部分画像を処理します！
「x0=x;k=tbl[x0];」で次のループの準備としてＸ座標始点
と係数の取り出しです！
次に、否成立中身ブロックは、
「y0=0;k=tbl[y0];」でＹ座標始点初期化と係数の取り出し
です！
「for(y=1;y<v;y++){・・ループ中身・・}」は、
ｆｏｒループ構文で初期化「y=1;」でＹ座標を１から
スタートし条件「y<v;」で「v-1」まで「y++」と一つずつ
増やしてブロックをループします！
そのループ中身ブロックで
「if(k!=tbl[y]){・・内側成立中身・・」と条件「
k!=tbl[y]」≪現係数の値がテーブルの係数と異なる場合に
処理する＝同じならば変換する意味が無い≫の場合に成立
中身を実行します！その内側成立中身は、
「y1=y-1;」は、Ｙ座標終点を算出！
「makeCvtLineLUTSingle(lut,k);」で基本単位のＬＵＴを
作成して置きます！
「subS.subset(ps,0,y0,h,y1-y0+1);
subD.subset(pd,0,y0,h,y1-y0+1);」でＳＤ両者の処理する
部分画像を「subS・subD」に取り出します！
「ConvertByte(&subS,&subD,lut);」でサブルーチンとし
て関数「ConvertByte();」で部分画像を処理します！
「y0=y;k=tbl[y0];」で次のループの準備としてＹ座標始点
と係数の取り出しです！
最後に「free(lut);return(END_STI);」と確保した
メモリーを解放し正常終了！
（４－１４－１０－Ｄ）関数「int ConvertLine()」の【備考】
この関数の使用例は、敢て記載しません！
この関数を製作した時を思い出したのだが、良く思い出せ
無いのでアルゴリズムコードから推測して、撮影条件が悪い
≪照明が傾いて居るとか、撮像機器に問題が有る≫場合の
画像補正を行って居ると推測したのでアルゴリズムコードと
して補正するとは、コンナ物ですと示す事を説明するだけと
します！
（４－１４－１１）関数「int ConvertLine(
TypeArray* ps,TypeArray* pd,
UWORD tbl[],int mode){・・・｝」の説明
int CopyClear::ConvertLine(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列
UWORD tbl[], // テーブル「1..1023」
int mode // 0→水平方向,1→垂直方向
){
BYTE* lut; // ＬＵＴバッファー
TypeArray subS; // 部分画像Ｓ
TypeArray subD; // 部分画像Ｄ
int h; // 水平幅
int v; // 垂直幅
int k; // 割合（255に対して）
int x; // Ｘ座標
int x0; // Ｘ座標：始点
int x1; // Ｘ座標：終点
int y; // Ｙ座標
int y0; // Ｙ座標：始点
int y1; // Ｙ座標：終点
int sti; // ステータス情報
sti = CheckImageByte( ps ); // 元画像検査
if( sti != END_STI ){ // 不正が有れば
return( sti ); // エラーステータスを返す
} //
sti = CheckImageByte( pd ); // 結果画像検査
if( sti != END_STI ){ // 不正が有れば
return( sti ); // エラーステータスを返す
} //
h = ( ps->h < pd->h ) ? ps->h : pd->h; // 有効水平幅算出
v = ( ps->v < pd->v ) ? ps->v : pd->v; // 有効垂直幅算出
if( mode == 0 ){ // 水平方向なら
lut = (BYTE*)malloc( sizeof(BYTE) * 256 * h ); // LUTを256*水平幅で確保
if( lut != 0 ){ // 確保成功時は
sti = makeCvtLineLUT( lut, tbl, h ); // 左記でＬＵＴ作成
if( sti != END_STI ){ // 不正が有れば
free( lut ); // ＬＵＴを解放
return( sti ); // エラーステータスを返す
} //
convertLineX( ps, pd, lut ); // 水平方向ＬＵＴ変換
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
} //
}else{ // 垂直方向なら
lut = (BYTE*)malloc( sizeof(BYTE) * 256 * v ); // LUTを256*垂直幅で確保
if( lut != 0 ){ // 確保成功時は
sti = makeCvtLineLUT( lut, tbl, v ); // 左記でＬＵＴ作成
if( sti != END_STI ){ // 不正が有れば
free( lut ); // ＬＵＴを解放
return( sti ); // エラーステータスを返す
} //
convertLineY( ps, pd, lut ); // 垂直方向ＬＵＴ変換
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
} //
} // ※大規模LUT確保失敗時の処理※
lut = (BYTE*)malloc( sizeof(BYTE) * 256 ); // LUTを256で確保
if( lut == 0 ){ // 確保失敗時は
return( STI_MEM ); // 左記を返す
} //
if( mode == 0 ){ // 水平方向なら
x0 = 0; // Ｘ座標：始点セット
k = tbl[x0]; // 先頭の割合取り出し
for( x = 1; x < h; x++ ){ // Ｘ座標を繰り返し
if( k != tbl[x] ){ // 同一割合で無くなれば
x1 = x - 1; // Ｘ座標：終点セット
makeCvtLineLUTSingle( lut, k ); // 左記でＬＵＴ作成
subS.subset( ps, x0, 0, x1 - x0 + 1, v ); // 部分画像Ｓセット
subD.subset( pd, x0, 0, x1 - x0 + 1, v ); // 部分画像Ｄセット
ConvertByte( &subS, &subD, lut ); // ＬＵＴ変換
x0 = x; // Ｘ座標：始点更新
k = tbl[x0]; // 割合更新
} //
} //
}else{ // 垂直方向なら
y0 = 0; // Ｙ座標：始点セット
k = tbl[y0]; // 先頭の割合取り出し
for( y = 1; y < v; y++ ){ // Ｙ座標を繰り返し
if( k != tbl[y] ){ // 同一割合で無くなれば
y1 = y - 1; // Ｙ座標：終点セット
makeCvtLineLUTSingle( lut, k ); // 左記でＬＵＴ作成
subS.subset( ps, 0, y0, h, y1 - y0 + 1 ); // 部分画像Ｓセット
subD.subset( pd, 0, y0, h, y1 - y0 + 1 ); // 部分画像Ｄセット
ConvertByte( &subS, &subD, lut ); // ＬＵＴ変換
y0 = y; // Ｙ座標：始点更新
k = tbl[y0]; // 割合更新
} //
} //
} //
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（４－１４－１１－Ａ）関数「int ConvertLine()」の【関数名】説明
「Convert」は、英単語「Convert」として変換するの意味で
す！ここの画像処理では、ＬＵＴ≪ルックアップテーブル≫
を使用したＳ（元）画像⇒ＬＵＴ変換⇒Ｄ（結果）画像への
画素データをＬＵＴ≪Lookuptable≫として一時的に変換す
る技法を使用して変換する関数ですが、
「Line」は、ココでは、線形（一次元的）に変換⇒元の撮影
画像が照明の関係で傾いている場合に補正を加える処理です
☆備考☆
この関数が何故、存在するかを解説して居る時に思い出した
撮影条件や、カメラの特性で画像の濃淡に機材固有のズレが
生じてアルゴリズムを工夫して補正する必要が遇ったからと
特殊用途で一般的な処理では有りません！
しかしながら、画像処理では撮影機材の問題は付き物なので
過去に如何に工夫したかが分かる例文として解説して行く事
★備考★
この関数には、オーバーロード（多重定義）として同じ
関数名で仮引数が異なる関数が存在します！
（４－１４－１１－Ｂ）関数「int ConvertLine()」の【返値】説明
int CopyClear::ConvertLine(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列
UWORD tbl[], // テーブル「1..1023」
int mode // 0→水平方向,1→垂直方向
){仮引数「TypeArray* ps,TypeArray* pd,」とＳ（元）画像
Ｄ（結果）画像共、検査関数「CheckImageBYTE ();」で検査
で１バイト単位で有るか無いかを検査し、この関数は、ＳＤ
両者が１バイト単位である事を検査し、エラーが有れば返し
終了します！
関数の実行時エラーとしてメモリー確保「lut=(BYTE *)
malloc(sizeof(BYTE )*256);」で変数「lut」が空
ポインタに成ったらエラー「STI_MEM」を返し終了します！
正常に最後まで実行し、正常終了「END_STI」を返し
終了します！
（４－１４－１１－Ｃ）関数「int ConvertLine()」の【仮引数】説明
int CopyClear::ConvertLine(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列
UWORD tbl[], // テーブル「1..1023」
int mode // 0→水平方向,1→垂直方向
){「TypeArray* ps,」は、Ｓ（元）画像を示す画像情報！
「TypeArray* pd,」は、Ｄ（結果）画像を示す画像情報！
「UWORD tbl[],」は、変換用のテーブルです！サイズは、
コメントに記載して居る「1..1023」では、１０２３と誤解
するかも知れませんが１０２４です！
★注意★ココの型が、「UWORD」と異なるのが、
「４－１４－１０」で説明した関数との違いです！
「int mode」は、モードで「mode＝0」で水平方向変換処理
「mode＝1」で垂直方向変換処理を示します！
（４－１４－１１－Ｄ）関数「int ConvertLine()」の【アルゴリズム】説明
){
BYTE* lut; // ＬＵＴバッファー
TypeArray subS; // 部分画像Ｓ
TypeArray subD; // 部分画像Ｄ
int h; // 水平幅
int v; // 垂直幅
int k; // 割合（255に対して）
int x; // Ｘ座標
int x0; // Ｘ座標：始点
int x1; // Ｘ座標：終点
int y; // Ｙ座標
int y0; // Ｙ座標：始点
int y1; // Ｙ座標：終点
int sti; // ステータス情報
sti = CheckImageByte( ps ); // 元画像検査
if( sti != END_STI ){ // 不正が有れば
return( sti ); // エラーステータスを返す
} //
sti = CheckImageByte( pd ); // 結果画像検査
if( sti != END_STI ){ // 不正が有れば
return( sti ); // エラーステータスを返す
} //
h = ( ps->h < pd->h ) ? ps->h : pd->h; // 有効水平幅算出
v = ( ps->v < pd->v ) ? ps->v : pd->v; // 有効垂直幅算出
if( mode == 0 ){ // 水平方向なら
lut = (BYTE*)malloc( sizeof(BYTE) * 256 * h ); // LUTを256*水平幅で確保
if( lut != 0 ){ // 確保成功時は
sti = makeCvtLineLUT( lut, tbl, h ); // 左記でＬＵＴ作成
if( sti != END_STI ){ // 不正が有れば
free( lut ); // ＬＵＴを解放
return( sti ); // エラーステータスを返す
} //
convertLineX( ps, pd, lut ); // 水平方向ＬＵＴ変換
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
} //
}else{ // 垂直方向なら
lut = (BYTE*)malloc( sizeof(BYTE) * 256 * v ); // LUTを256*垂直幅で確保
if( lut != 0 ){ // 確保成功時は
sti = makeCvtLineLUT( lut, tbl, v ); // 左記でＬＵＴ作成
if( sti != END_STI ){ // 不正が有れば
free( lut ); // ＬＵＴを解放
return( sti ); // エラーステータスを返す
} //
convertLineY( ps, pd, lut ); // 垂直方向ＬＵＴ変換
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
} //
} // ※大規模LUT確保失敗時の処理※
lut = (BYTE*)malloc( sizeof(BYTE) * 256 ); // LUTを256で確保
if( lut == 0 ){ // 確保失敗時は
return( STI_MEM ); // 左記を返す
} //
if( mode == 0 ){ // 水平方向なら
x0 = 0; // Ｘ座標：始点セット
k = tbl[x0]; // 先頭の割合取り出し
for( x = 1; x < h; x++ ){ // Ｘ座標を繰り返し
if( k != tbl[x] ){ // 同一割合で無くなれば
x1 = x - 1; // Ｘ座標：終点セット
makeCvtLineLUTSingle( lut, k ); // 左記でＬＵＴ作成
subS.subset( ps, x0, 0, x1 - x0 + 1, v ); // 部分画像Ｓセット
subD.subset( pd, x0, 0, x1 - x0 + 1, v ); // 部分画像Ｄセット
ConvertByte( &subS, &subD, lut ); // ＬＵＴ変換
x0 = x; // Ｘ座標：始点更新
k = tbl[x0]; // 割合更新
} //
} //
}else{ // 垂直方向なら
y0 = 0; // Ｙ座標：始点セット
k = tbl[y0]; // 先頭の割合取り出し
for( y = 1; y < v; y++ ){ // Ｙ座標を繰り返し
if( k != tbl[y] ){ // 同一割合で無くなれば
y1 = y - 1; // Ｙ座標：終点セット
makeCvtLineLUTSingle( lut, k ); // 左記でＬＵＴ作成
subS.subset( ps, 0, y0, h, y1 - y0 + 1 ); // 部分画像Ｓセット
subD.subset( pd, 0, y0, h, y1 - y0 + 1 ); // 部分画像Ｄセット
ConvertByte( &subS, &subD, lut ); // ＬＵＴ変換
y0 = y; // Ｙ座標：始点更新
k = tbl[y0]; // 割合更新
} //
} //
} //
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
}ローカル変数
){
BYTE* lut; // ＬＵＴバッファー
TypeArray subS; // 部分画像Ｓ
TypeArray subD; // 部分画像Ｄ
int h; // 水平幅
int v; // 垂直幅
int k; // 割合（255に対して）
int x; // Ｘ座標
int x0; // Ｘ座標：始点
int x1; // Ｘ座標：終点
int y; // Ｙ座標
int y0; // Ｙ座標：始点
int y1; // Ｙ座標：終点
int sti; // ステータス情報「BYTE *lut;」は、内部で使用するＬＵＴです！
「TypeArraysubS;」は、Ｓ画像の部分画像用
「TypeArraysubD;」は、Ｄ画像の部分画像用
「int h;」は、内部でサイズ調整に使用した水平幅
「int v;」は、内部でサイズ調整に使用した垂直幅
「int k;」は、仮引数「BYTE tbl[],」に格納している
係数を内部で扱い易い様に取り出した変数です！
「int x;」は、Ｘ座標の値！
「int x0;」は、Ｘ座標の範囲で始点！
「int x1;」は、Ｘ座標の範囲で終点！
「int y;」は、Ｙ座標の値！
「int y0;」はＹ座標の範囲で始点！、
「int y1;」はＹ座標の範囲で終点！、
「int sti;」は、関数の返値の一次置き場！
アルゴリズムコード
sti = CheckImageByte( ps ); // 元画像検査
if( sti != END_STI ){ // 不正が有れば
return( sti ); // エラーステータスを返す
} //
sti = CheckImageByte( pd ); // 結果画像検査
if( sti != END_STI ){ // 不正が有れば
return( sti ); // エラーステータスを返す
} //
h = ( ps->h < pd->h ) ? ps->h : pd->h; // 有効水平幅算出
v = ( ps->v < pd->v ) ? ps->v : pd->v; // 有効垂直幅算出
if( mode == 0 ){ // 水平方向なら
lut = (BYTE*)malloc( sizeof(BYTE) * 256 * h ); // LUTを256*水平幅で確保
if( lut != 0 ){ // 確保成功時は
sti = makeCvtLineLUT( lut, tbl, h ); // 左記でＬＵＴ作成
if( sti != END_STI ){ // 不正が有れば
free( lut ); // ＬＵＴを解放
return( sti ); // エラーステータスを返す
} //
convertLineX( ps, pd, lut ); // 水平方向ＬＵＴ変換
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
} //
}else{ // 垂直方向なら
lut = (BYTE*)malloc( sizeof(BYTE) * 256 * v ); // LUTを256*垂直幅で確保
if( lut != 0 ){ // 確保成功時は
sti = makeCvtLineLUT( lut, tbl, v ); // 左記でＬＵＴ作成
if( sti != END_STI ){ // 不正が有れば
free( lut ); // ＬＵＴを解放
return( sti ); // エラーステータスを返す
} //
convertLineY( ps, pd, lut ); // 垂直方向ＬＵＴ変換
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
} //
} // ※大規模LUT確保失敗時の処理※
lut = (BYTE*)malloc( sizeof(BYTE) * 256 ); // LUTを256で確保
if( lut == 0 ){ // 確保失敗時は
return( STI_MEM ); // 左記を返す
} //
if( mode == 0 ){ // 水平方向なら
x0 = 0; // Ｘ座標：始点セット
k = tbl[x0]; // 先頭の割合取り出し
for( x = 1; x < h; x++ ){ // Ｘ座標を繰り返し
if( k != tbl[x] ){ // 同一割合で無くなれば
x1 = x - 1; // Ｘ座標：終点セット
makeCvtLineLUTSingle( lut, k ); // 左記でＬＵＴ作成
subS.subset( ps, x0, 0, x1 - x0 + 1, v ); // 部分画像Ｓセット
subD.subset( pd, x0, 0, x1 - x0 + 1, v ); // 部分画像Ｄセット
ConvertByte( &subS, &subD, lut ); // ＬＵＴ変換
x0 = x; // Ｘ座標：始点更新
k = tbl[x0]; // 割合更新
} //
} //
}else{ // 垂直方向なら
y0 = 0; // Ｙ座標：始点セット
k = tbl[y0]; // 先頭の割合取り出し
for( y = 1; y < v; y++ ){ // Ｙ座標を繰り返し
if( k != tbl[y] ){ // 同一割合で無くなれば
y1 = y - 1; // Ｙ座標：終点セット
makeCvtLineLUTSingle( lut, k ); // 左記でＬＵＴ作成
subS.subset( ps, 0, y0, h, y1 - y0 + 1 ); // 部分画像Ｓセット
subD.subset( pd, 0, y0, h, y1 - y0 + 1 ); // 部分画像Ｄセット
ConvertByte( &subS, &subD, lut ); // ＬＵＴ変換
y0 = y; // Ｙ座標：始点更新
k = tbl[y0]; // 割合更新
} //
} //
} //
free( lut ); // ＬＵＴを解放
return( END_STI ); // 正常終了
}「sti=CheckImageBYTE (ps);if(sti!=END_STI){
return(sti);}」は、
仮引数検査関数「sti=CheckImageBYTE (ps);」で
Ｓ（元）画像が１バイト単位画像か如何か検査し、
判定「if(sti!=END_STI)」で異なれば「return(sti);」と
エラーを返し関数終了！
「sti=CheckImageBYTE (pd);if(sti!=END_STI){
return(sti);}」は、
Ｄ（結果）画像が１バイト検査！
「h=(ps->h<pd->h)?ps->h:pd->h;」は、ＳＤ両者の水平幅
での有効幅（最小幅）算出！
「v=(ps->v<pd->v)?ps->v:pd->v;」は、ＳＤ両者の垂直幅
での有効幅（最小幅）算出！
「if(mode==0){・・成立中身・・}else{
・・否成立中身・・}」は、条件「(mode==0)」と
仮引数「int mode」が、０の場合、成立中身ブロックを
処理し、それ以外の場合、否成立中身ブロックを処理します
先ず、成立中身ブロックは、
「lut=(BYTE *)malloc(sizeof(BYTE )256h);」とメモリ
確保します！確保するサイズは「sizeof(UWORD)*256*h」と
「sizeof(UWORD)」でUWORD型（勿論、unsignedchar）なので
１に成るのですが
★注意★未知のＣＰＵ＆処理系にも対応する為にワザワザ
「sizeof(型名)」の記述を採用しました！
そして「256*h」と水平幅×２５６をメモリ取得サイズと
しています！水平幅分１バイト単位のＬＵＴが存在するとの
意味です！そして「if(lut!=0){・・メモリ取得成功時」は、
「sti=makeCvtLineLUT(lut,tbl,h);」で下請けのサブルー
チン「makeCvtLineLUT()」でＬＵＴパターン作成処理し、
★注意★ココでサブルーチンとして使用している関数は、
「４－１４－１０－Ｄ」で説明した関数と同じ名前ですが
仮引数「UWORDtbl[],」とUWORD型と型が異なる多重定義
（オーバーロード）関数と物が違う事に留意して下さい！
「if(sti!=END_STI){free(lut);return(sti);」と
処理失敗「sti!=END_STI」ならば「free(lut);」で取得
したメモリを後始末とし解放し、エラーコード「sti」を
返し関数終了！★注意★エラー時のメモリ解放は必須です！
「convertLineX(ps,pd,lut);free(lut);
return(END_STI);」は、サブルーチン「convertLineX()」で
先ほど作成したＬＵＴを使用してＸ座標方向の傾き校正処理
を行います！そして「free(lut);」で取得したメモリを
後始末とし解放し、関数正常終了！★注意★勿論、正常終了
でもメモリ解放は必須です！
次に、否成立中身ブロックは、
「lut=(BYTE *)malloc(sizeof(BYTE )*256*v);」とメモリ
確保します！
そして「256v」と垂直幅×２５６をメモリ取得サイズと
しています！垂直幅分１バイト単位のＬＵＴが存在するとの
意味です！
そして「if(lut!=0){・・メモリ取得成功時」は、
「sti=makeCvtLineLUT(lut,tbl,v);」で下請けの
サブルーチン「makeCvtLineLUT()」でＬＵＴパターン作成
処理し、
★注意★ココでサブルーチンとして使用している関数は、
「４－１４－１０－Ｄ」で説明した関数と同じ名前ですが
仮引数「UWORD tbl[],」とUWORD型と型が異なる多重定義
（オーバーロード）関数と物が違う事に留意して下さい！
「if(sti!=END_STI){free(lut);return(sti);」と
処理失敗「sti!=END_STI」ならば「free(lut);」で取得
したメモリを後始末とし解放し、エラーコード「sti」を
返し関数終了！
「convertLineY(ps,pd,lut);free(lut);
return(END_STI);」は、
サブルーチン「convertLineY()」で先ほど作成したＬＵＴを
使用してＹ座標方向の傾き校正処理を行います！
そして「free(lut);」で取得したメモリを後始末とし
解放し、関数正常終了！
★注意★ココまでで関数の大まかな通常処理の説明は終わり
ですが、「lut=(BYTE *)malloc(sizeof(BYTE)*256*h);」
及び
「lut=(BYTE *)malloc(sizeof(BYTE)*256*v);」のメモリ
確保で「if(lut!=0){」と確保成功した場合の処理しか
説明して無い事に注意して下さい！
勿論、大概のシステムでは成功する筈ですのでコレから
説明する部分は、メモリをケチって居るシステムの為の処理
です！
詰り、上記「malloc()」が失敗した場合の処理です！
「lut=(BYTE *)malloc(sizeof(BYTE)*256);」は、
１単位分変換用のＬＵＴをメモリ確保した事を示します！
「if(lut==0){return(STI_MEM);}」は、このサイズでも確保
失敗したらエラー「STI_MEM」を返し関数終了！
そして再び、仮引数「int mode」が、０の場合、成立中身
ブロックを処理し、それ以外の場合、否成立中身ブロックを
処理します！
先ず、成立中身ブロックは、
「x0=0;k=tbl[x0];」でＸ座標始点初期化と係数の取り出し
です！
「for(x=1;x<h;x++){・・ループ中身・・}」は、
ｆｏｒループ構文で初期化「x=1;」でＸ座標を１から
スタートし条件「x<h;」で「h-1」まで「x++」と一つずつ
増やしてブロックをループします！
そのループ中身ブロックで
「if(k!=tbl[x]){・・内側成立中身・・」と条件「
k!=tbl[x]」≪現係数の値がテーブルの係数と異なる場合に
処理する＝同じならば変換する意味が無い≫の場合に成立
中身を実行します！その内側成立中身は、
「x1=x-1;」は、Ｘ座標終点を算出！
「makeCvtLineLUTSingle(lut,k);」で基本単位のＬＵＴを
作成して置きます！
「subS.subset(ps,x0,0,x1-x0+1,v);
subD.subset(pd,x0,0,x1-x0+1,v);」でＳＤ両者の処理する
部分画像を「subS・subD」に取り出します！
「ConvertByte(&subS,&subD,lut);」でサブルーチンとし
て関数「ConvertByte();」で部分画像を処理します！
「x0=x;k=tbl[x0];」で次のループの準備としてＸ座標始点
と係数の取り出しです！
次に、否成立中身ブロックは、
「y0=0;k=tbl[y0];」でＹ座標始点初期化と係数の取り出し
です！
「for(y=1;y<v;y++){・・ループ中身・・}」は、ｆｏｒ
ループ構文で初期化「y=1;」でＹ座標を１からスタートし
条件「y<v;」で「v-1」まで「y++」と一つずつ増やして
ブロックをループします！そのループ中身ブロックで
「if(k!=tbl[y]){・・内側成立中身・・」と条件「
k!=tbl[y]」≪現係数の値がテーブルの係数と異なる場合に
処理する＝同じならば変換する意味が無い≫の場合に成立
中身を実行します！その内側成立中身は、
「y1=y-1;」は、Ｙ座標終点を算出！
「makeCvtLineLUTSingle(lut,k);」で基本単位のＬＵＴを
作成して置きます！
「subS.subset(ps,0,y0,h,y1-y0+1);
subD.subset(pd,0,y0,h,y1-y0+1);」でＳＤ両者の処理する
部分画像を「subS・subD」に取り出します！
「ConvertByte(&subS,&subD,lut);」でサブルーチンとし
て関数「ConvertByte();」で部分画像を処理します！
「y0=y;k=tbl[y0];」で次のループの準備としてＹ座標始点
と係数の取り出し
です！
最後に「free(lut);return(END_STI);」と確保した
メモリーを解放し正常終了！
（４－１４－１１－Ｄ）関数「int ConvertLine()」の【備考】
この関数の使用例は、敢て記載しません！
この関数を製作した時を思い出したのだが、良く思い出せ
無いのでアルゴリズムコードから推測して、撮影条件が悪い
≪照明が傾いて居るとか、撮像機器に問題が有る≫場合の
画像補正を行って居ると推測したのでアルゴリズムコードと
して補正するとは、コンナ物ですと示す事を説明するだけと
します！
※特に注意※
ココの「４－１４－１１」と一つ前の「４－１４－１０」
で説明した関数「int ConvertLine()」は、ココの字面だけ
の解釈では、役に立つ関数とは、現時点（２０２４年３月）
では思えません！
と作者が、思い出せ無かった事を記載して置きます！
まっＣ言語のアルゴリズムコードの見本ぐらいに利用して
下さい！
（４－１４－１２）関数「int Binarization(
TypeArray* ps,TypeArray* pd,
int t,int data=255,int low=0){・・・｝」の説明
int CopyClear::Binarization(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列
int t, // しきい値 0..255
int data, // 出力値：高位（省略時=255）
int low // 出力値：低位（省略時=0）
){
BYTE lut[ 256 ]; // ＬＵＴバッファー
up_fill_void( low, lut, t ); // LUT[0..t] =low
up_fill_void( data, &lut[ t ], 256 - t ); // LUT[t..255]=data
return( ConvertByte( ps, pd, lut ) ); // LUT変換で２値化
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（４－１４－１２－Ａ）関数「Binarization()」の【関数名】説明
「Binarization」は、英単語でと言うか、画像処理の専門
用語で「二値化」≪多値画像（通常の撮像カメラ単色では、
８ビット画素画像・特殊用途の高性能カメラ単色では、
１０ビットとか画素の値が有りますが、メモリの都合で
１６ビット画素画像）等と扱いますが、
其れを白画素（８ビット画像の場合、数値「１」で表すか、
「２５５」と表示して明るい白に成る事を選ぶかは、
アプリの都合です）が、黒画素（この場合、数値「０」と
数値としても表示上のアプリ都合でも漆黒を意味する黒
「数値０」）と表現します！黒（０）で白（≠０）と成ると
考えて下さい！
この二値画素画像の考え方は基本ですので画像処理を扱う
場合の基本のキですから！良く理解して下さい！≫
そしてBinarization()関数は、多値画像を二値画像に変換す
る関数で有ると理解して下さい！
（４－１４－１２－Ｂ）関数「int Binarization()」の【返値】説明
int CopyClear::Binarization(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列
int t, // しきい値 0..255
int data, // 出力値：高位（省略時=255）
int low // 出力値：低位（省略時=0）
){「return(ConvertByte(ps,pd,lut));」とサブルーチンの
関数「ConvertByte()」の実行時の返値を返します！
（４－１４－１２－Ｃ）関数「Binarization()」の【仮引数】説明
int CopyClear::Binarization(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列
int t, // しきい値 0..255
int data, // 出力値：高位（省略時=255）
int low // 出力値：低位（省略時=0）
){「TypeArray* ps,」は、Ｓ（元）画像情報です！
「TypeArray* pd,」は、Ｄ（結果）画像情報です！
「int t,」は、閾値（しきい値）と二値の切れ目です！
「int data,」は、白画素の値です！★注意★実引数の
省略時＝２５５と８ビット画像最大値にして居ます！
勿論、論理的演算では、「TRUE＝真」として扱います！
「int low」は、黒画素の値です！★注意★実引数の
省略時＝０と自然数最小値で表示上漆黒にして居ます！
勿論、論理的演算では、「FALSE＝偽」として扱います！
（４－１４－１２－Ｄ）関数「Binarization()」の【アルゴリズム】説明
){
BYTE lut[ 256 ]; // ＬＵＴバッファー
up_fill_void( low, lut, t ); // LUT[0..t] =low
up_fill_void( data, &lut[ t ], 256 - t ); // LUT[t..255]=data
return( ConvertByte( ps, pd, lut ) ); // LUT変換で２値化
}ローカル変数
){
BYTE lut[ 256 ]; // ＬＵＴバッファー「BYTE lut[256];」は、内部で使用する変換用ＬＵＴです！
アルゴリズムコード
up_fill_void( low, lut, t ); // LUT[0..t] =low
up_fill_void( data, &lut[ t ], 256 - t ); // LUT[t..255]=data
return( ConvertByte( ps, pd, lut ) ); // LUT変換で２値化
}「up_fill_void (low,lut,t);」は、ＬＵＴ配列の
[0]から[t-1]の範囲と仮引数「int t,」閾値（しきい値）
未満の場所を仮引数「int low」と黒画素の値をセット！
「up_fill_void (data,&lut[t],256-t);」は、ＬＵＴ配列の
[t]から[256-t]と仮引数「int t,」閾値（しきい値）
以上の場所を仮引数「int data,」と白画素の値をセット！
★注意★ココまでで二値化パターン作成用ＬＵＴが出来まし
た！そしてＳ（元）画像が８ビット画像画素≪0..255範囲≫
「return(ConvertByte(ps,pd,lut));」は、サブルーチン
とし関数「ConvertByte()」で二値化ＬＵＴで
仮引数「TypeArray* ps,」８ビット画素画像としてＬＵＴ
変換し、仮引数「TypeArray* pd,」に結果画像が二値画素
画像に成る事を理解して下さい！★注意★更にコノ関数は
使用頻度の多い≪多値画像から二値画像に変換し二値画像
処理を行う標準的な前段処理に使用します！≫
（４－１４－１２－Ｅ）関数「Binarization()」の【使用例】説明
{
TypeArray PatImg; // 画像型変数
// ：編か前のパターン画像
TypeArray* pPatImg=&PatImg; // 上記へのポインタ
TypeArray Wimg; // 画像型変数
//：フィル書き込み用
TypeArray* pWimg=&Wimg; // 上記へのポインタ
//：部分画像用
TypeArray* pimgA=&PatImg; // 部分画像用
TypeArray* pimgB=&PatImg; // 部分画像用
long hgm[256]; // ヒストグラム算出データ配列
int t; // ２値化しきい値
int sti; // ステータス情報
pPatImg->MallocBYTE( 640, 480 ); // サイズ６４０×４８０画像メモリ取得
FUN.Clear( pPatImg, 0 ); // 画像メモリ「０クリア」
pWimg->MallocBYTE( 640, 480 ); // サイズ６４０×４８０画像メモリ取得
FUN.Clear( pWimg, 0 ); // 画像メモリ「０クリア」
// 典型的な２値化画像生成方法での処理
// サンプルパターン画像作成
FUN.Clear( pPatImg, 100 ); // 画像メモリ「画素データ100でクリア」
pimgA->subset( pPatImg, 100, 200, // 座標範囲（100,200）⇒（149,229）の範囲の
50, 30 ); // 部分画像を用意
FUN.Clear( pimgA, 200 ); // 部分画像を画素データ200でクリア
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile7.bmp", pPatImg );
// 典型的な２値化しきい値を算出する方法
FUN.HistogramImage( pPatImg, hgm ); // 画像の画素濃度ヒストグラム産出
t = FUN.GetBinOotu( hgm, 256 ); // 大津法と言う画像処理で一般的な産出手法で
// 濃度ヒストグラム・データから、しきい値産出
FUN.Binarization( pPatImg, pWimg, t ); // 今回紹介する関数「Binarization()」で２値化
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile8.bmp", pWimg );
// 後始末
pPatImg->freeMem(); // 画像メモリ解放
pWimg->freeMem(); // 画像メモリ解放
}★注意★
上記例文で注意して欲しいのは、ＬＵＴは、用意して無い事
です！関数「Binarization()」の中でＬＵＴをローカルに
使用してＬＵＴ変換を内部で行って居る事です！
更に、「long hgm[256];」を用意して多値画像「PatImg」の
ヒストグラム（画素度数分布）作成し、そのヒストグラム
データから、閾値（しきい値）を作成して
関数「Binarization()」で二値画像に変換する事を
記載して居る事を理解して下さい！この二値画像に変換
する方法は、標準的な方法なので覚えて下さい！
取り敢えず、本日（３月２０）の講義は、ココまでにし
ます！何だか、疲れたのだ！受講されている方も
お疲れと思いますのでココまでとします！
まだ、Ｎｏｔｅサーバーが快適に動く分量ですから、
引き続き、この文章に続きは、載せます！
２０２４年３月２２続講
（４－１４－１３）関数「int BinarizationMyself(
TypeArray* p,int data);{・・・｝」の説明
int CopyClear::BinarizationMyself(
TypeArray *p, // 配列（画像）情報
int data // 出力値：≠０時
){
BYTE *ptr; // 画像ポインタ
int h; // 水平幅
int v; // 垂直幅
int inc; // 増加幅
if( p->w != 1 ){ // 画素単位＝１以外
return( STI_ARY_5 ); // 左記を返す
} //
ptr = (BYTE*)p->adr; // 画像Ptrを取り出し
inc = p->inc; // 増加幅を取り出し
h = p->h; // 水平／垂直幅を
v = p->v; // 取り出し
while( --v >= 0 ){ // 垂直方向に繰返し
BinarizationMyselfBase( ptr, h, data ); // 水平方向処理
ptr += inc; // 垂直方向に進める
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
※関数内のコメントに対する備考※「：Ｃ関数専用：」との
記載は、ＰＩＰＬと言うコマンド言語からはアクセス出来る
様に設計して無いとの意味でＣ／Ｃ＋＋で使用する場合は、
普通に使用出来る事を意味します！
（４－１４－１３－Ａ）関数「BinarizationMyself()」の【関数名】説明
「Binarization」は、二値化を意味し、
「Myself」は、英単語「Myself」の意味通り「自分自身」
です⇒仮引数「TypeArray* p,」と画像情報が一つしか
無い事に注目して下さい！自分自身とは、Ｓ（元）画像と
Ｄ（結果）画像が同じ画像で画像自体が二値化する事に成り
ます！
（４－１４－１３－Ｂ）関数「int BinarizationMyself()」の【返値】説明
int CopyClear::BinarizationMyself(
TypeArray *p, // 配列（画像）情報
int data // 出力値：≠０時
){この関数内で明示的に検査しているのは、
仮引数「TypeArray* p,」が１バイト単位か否かで１バイト
で無ければエラーコード「STI_ARY_5」を返します！
最後まで実行時は、正常終了「END_STI」を返します！
（４－１４－１３－Ｃ）関数「BinarizationMyself()」の【仮引数】説明
int CopyClear::BinarizationMyself(
TypeArray *p, // 配列（画像）情報
int data // 出力値：≠０時
){「TypeArray* p,」は、画像情報です！Ｓ（元）画像も
Ｄ（結果）画像が同じ画像情報です！
「int data」は、白画素の値です！
（４－１４－１３－Ｄ）関数「BinarizationMyself()」の【アルゴリズム】説明
){
BYTE *ptr; // 画像ポインタ
int h; // 水平幅
int v; // 垂直幅
int inc; // 増加幅
if( p->w != 1 ){ // 画素単位＝１以外
return( STI_ARY_5 ); // 左記を返す
} //
ptr = (BYTE*)p->adr; // 画像Ptrを取り出し
inc = p->inc; // 増加幅を取り出し
h = p->h; // 水平／垂直幅を
v = p->v; // 取り出し
while( --v >= 0 ){ // 垂直方向に繰返し
BinarizationMyselfBase( ptr, h, data ); // 水平方向処理
ptr += inc; // 垂直方向に進める
} //
return( END_STI ); // 正常終了
}ローカル変数
){
BYTE *ptr; // 画像ポインタ
int h; // 水平幅
int v; // 垂直幅
int inc; // 増加幅「BYTE *ptr;」は、１バイト単位画素への実アクセス
ポインタです！このポインタへの操作を行います！
「int h;int v;int inc;」は、は、内部で使用し易い（
高速化）の為に一旦、内部の単純な変数に画像情報の水平・
垂直・増加幅を代入した物です！
アルゴリズムコード
if( p->w != 1 ){ // 画素単位＝１以外
return( STI_ARY_5 ); // 左記を返す
} //
ptr = (BYTE*)p->adr; // 画像Ptrを取り出し
inc = p->inc; // 増加幅を取り出し
h = p->h; // 水平／垂直幅を
v = p->v; // 取り出し
while( --v >= 0 ){ // 垂直方向に繰返し
BinarizationMyselfBase( ptr, h, data ); // 水平方向処理
ptr += inc; // 垂直方向に進める
} //
return( END_STI ); // 正常終了
}「if(p->w!=1){return(STI_ARY_5);}」は、
仮引数「TypeArray* p,」が１バイト単位で無い場合は
エラーコード「STI_ARY_5」を返し関数終了！
「ptr=(BYTE *)p->adr;」は、画素操作ポインタをセット！
「inc=p->inc;h=p->h;v=p->v;」は、内部で使用し易い（
高速化）の為に一旦、単純な変数に画像情報の水平・垂直・
増加幅を代入した物です！
「while(--v>=0){・・ループ本体・・}」は、
ループ条件「--v>=0」で垂直幅の数分「ループ本体」を
ループ（繰り返す）処理です★備考★「while(--v>=0」の
様に「--v>=0」とデクリメント演算子で変数値が変化して
も影響が無い応用には、経験上最適なＣＰＵ機械コードが
生成出来るので、この画像処理ライブラリは、この記法を
多用して居ます！学校の教科書的には余り教えて無い（恐ら
く変数の値が変わる事を説明する必要が有るので説明がヤヤ
コシク成る事を嫌ったと推測）と思いますが、兎も角、高速
に動かすには、この記法がベストと考えて採用しています！
ループ条件「--v>=0」で垂直幅の数分繰り返すと言う事は、
水平方向の処理を垂直幅の数分繰り返すとの意味で
ループ本体「BinarizationMyselfBase(ptr,h,data);
ptr+=inc;」は、水平方向の処理としてサブルーチン
関数「BinarizationMyselfBase(ptr,h,data);」で処理し、
「ptr+=inc;」でポインタを増加幅分進めるとの意味で
次の処理行へ移動との意味です！★備考★この様に外側
ループで垂直方向を繰り返し「{}」とブロック内で水平
方向の処理を行うと言う方法は、この画像処理ライブラリで
多用しているアルゴリズムコード記載法です！
★注意★順番的に後で解説する事に成りますが、サブルーチ
ン関数「BinarizationMyselfBase()」は、水平方向の処理
で「画素≠0」の場合に仮引数「int data」に画素を置き換え
る関数です！
「return(END_STI);」は、正常終了を返値として返し
関数終了
（４－１４－１３－Ｅ）関数「BinarizationMyself()」の【使用例】説明
{
TypeArray PatImg; // 画像型変数
// パターン画像
TypeArray* pPatImg=&PatImg; // 上記へのポインタ
//：部分画像用
TypeArray* pimgA=&PatImg; // 部分画像用
int sti; // ステータス情報
pPatImg->MallocBYTE( 640, 480 ); // サイズ６４０×４８０画像メモリ取得
FUN.Clear( pPatImg, 0 ); // 画像メモリ「０クリア」
// 典型的な２値化画像生成方法での処理
// サンプルパターン画像作成
FUN.Clear( pPatImg, 100 ); // 画像メモリ「画素データ100でクリア」
pimgA->subset( pPatImg, 100, 200, // 座標範囲（100,200）⇒（149,229）の範囲の
50, 30 ); // 部分画像を用意
FUN.Clear( pimgA, 200 ); // 部分画像を画素データ200でクリア
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile7.bmp", pPatImg );
FUN.BinarizationMyself( pPatImg, 255 ); // 今回紹介する関数「BinarizationMyself()」で２値化
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile8.bmp", pPatImg );
// 後始末
pPatImg->freeMem(); // 画像メモリ解放
}★注意★
上記例文で注意して欲しいのは、ＬＵＴは、用意して無い事
です！関数「BinarizationMyself()」の中でＬＵＴをローカル
に使用してＬＵＴ変換を内部で行って居る事です！
更に、黒画素「＝0」・白画素を「≠0」と見なして結果の
白画素を「255」にします！
（４－１４－１４）関数「int BinarizationNonZeo(
TypeArray* ps,TypeArray* pd,int data){・・・｝」の説明
int CopyClear::BinarizationNonZeo(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列（画像）
int data // 出力値：≠０時
){
BYTE *ptrs; // Ｓ画像ポインタ
BYTE *ptrd; // Ｄ画像ポインタ
int h; // 水平幅
int v; // 垂直幅
int inc_s; // Ｓ増加幅
int inc_d; // Ｄ増加幅
if( ps->w != 1 || pd->w != 1 ){ // 画素単位＝１以外
return( STI_ARY_5 ); // 左記を返す
} //
ptrs = (BYTE*)ps->adr; // ＳPtrを取り出し
ptrd = (BYTE*)pd->adr; // ＤPtrを取り出し
inc_s = ps->inc; // Ｓ増加幅を取出
inc_d = pd->inc; // Ｄ増加幅を取出
h = ps->h; // 水平／垂直幅を
v = ps->v; // 取り出し
if( h > pd->h ){ // 水平幅を小の方に
h = pd->h; // 補正
} //
if( v > pd->v ){ // 垂直幅を小の方に
v = pd->v; // 補正
} //
while( --v >= 0 ){ // 垂直方向に繰返し
BinarizationNonZeoBase( ptrs, ptrd, h, data ); // 水平方向処理
ptrs += inc_s; // 垂直方向に進める
ptrd += inc_d; // 垂直方向に進める
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
※関数内のコメントに対する備考※「：Ｃ関数専用：」との
記載は、ＰＩＰＬと言うコマンド言語からはアクセス出来る
様に設計して無いとの意味でＣ／Ｃ＋＋で使用する場合は、
普通に使用出来る事を意味します！
（４－１４－１４－Ａ）関数「BinarizationNonZeo()」の【関数名】説明
「Binarization」は、二値化を意味し、
「NonZeo」は、「≠0」を意味します！関数の動作としたら
「４－１４－１３」で説明した
関数「BinarizationMyself()」の仮引数が自分自身で無く、
ＳＤ両画像情報独立に指定出来る事が異なります！
（４－１４－１４－Ｂ）関数「int BinarizationNonZeo()」の【返値】説明
int CopyClear::BinarizationNonZeo(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列（画像）
int data // 出力値：≠０時
){この関数内で明示的に検査しているのは、
仮引数「TypeArray* ps,TypeArray* pd,」が、
１バイト単位か否かで１バイトで無ければ
エラーコード「STI_ARY_5」を返します！
最後まで実行時は、正常終了「END_STI」を返します！
（４－１４－１４－Ｃ）関数「BinarizationNonZeo()」の【仮引数】説明
int CopyClear::BinarizationNonZeo(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列（画像）
int data // 出力値：≠０時
){「TypeArray* ps,」は、Ｓ（元）画像情報
「TypeArray* pd,」は、Ｄ（結果）画像情報
「int data」は、白画素の値です！
（４－１４－１４－Ｄ）関数「BinarizationNonZeo()」の【アルゴリズム】説明
){
BYTE *ptrs; // Ｓ画像ポインタ
BYTE *ptrd; // Ｄ画像ポインタ
int h; // 水平幅
int v; // 垂直幅
int inc_s; // Ｓ増加幅
int inc_d; // Ｄ増加幅
if( ps->w != 1 || pd->w != 1 ){ // 画素単位＝１以外
return( STI_ARY_5 ); // 左記を返す
} //
ptrs = (BYTE*)ps->adr; // ＳPtrを取り出し
ptrd = (BYTE*)pd->adr; // ＤPtrを取り出し
inc_s = ps->inc; // Ｓ増加幅を取出
inc_d = pd->inc; // Ｄ増加幅を取出
h = ps->h; // 水平／垂直幅を
v = ps->v; // 取り出し
if( h > pd->h ){ // 水平幅を小の方に
h = pd->h; // 補正
} //
if( v > pd->v ){ // 垂直幅を小の方に
v = pd->v; // 補正
} //
while( --v >= 0 ){ // 垂直方向に繰返し
BinarizationNonZeoBase( ptrs, ptrd, h, data ); // 水平方向処理
ptrs += inc_s; // 垂直方向に進める
ptrd += inc_d; // 垂直方向に進める
} //
return( END_STI ); // 正常終了
}ローカル変数
){
BYTE *ptrs; // Ｓ画像ポインタ
BYTE *ptrd; // Ｄ画像ポインタ
int h; // 水平幅
int v; // 垂直幅
int inc_s; // Ｓ増加幅
int inc_d; // Ｄ増加幅「BYTE *ptrs;」は、Ｓ（元）画像の実操作ポインタです！
「BYTE *ptrd;」は、Ｄ（結果）画像の実操作ポインタ
です！
「int h;」は、ＳＤ両画像の有効（最小）水平幅です！
「int v;」は、ＳＤ両画像の有効（最小）垂直幅です！
「int inc_s;」は、Ｓ（元）画像の増加幅！
「int inc_d;」は、Ｄ（結果）画像の増加幅！
「int h;int v;int inc_s;int inc_d;」は、は、内部で
使用するサイズに調整と使用し易い（高速化）の為に一旦、
内部の単純な変数に画像情報の水平・垂直・増加幅を代入
した物です！
アルゴリズムコード
if( ps->w != 1 || pd->w != 1 ){ // 画素単位＝１以外
return( STI_ARY_5 ); // 左記を返す
} //
ptrs = (BYTE*)ps->adr; // ＳPtrを取り出し
ptrd = (BYTE*)pd->adr; // ＤPtrを取り出し
inc_s = ps->inc; // Ｓ増加幅を取出
inc_d = pd->inc; // Ｄ増加幅を取出
h = ps->h; // 水平／垂直幅を
v = ps->v; // 取り出し
if( h > pd->h ){ // 水平幅を小の方に
h = pd->h; // 補正
} //
if( v > pd->v ){ // 垂直幅を小の方に
v = pd->v; // 補正
} //
while( --v >= 0 ){ // 垂直方向に繰返し
BinarizationNonZeoBase( ptrs, ptrd, h, data ); // 水平方向処理
ptrs += inc_s; // 垂直方向に進める
ptrd += inc_d; // 垂直方向に進める
} //
return( END_STI ); // 正常終了
}「if(ps->w!=1||pd->w!=1){return(STI_ARY_5);}」は、
ＳＤ両画像共画素単位が１バイトで無ければ、エラーコード
「STI_ARY_5」を返し関数終了！
「ptrs=(BYTE )ps->adr;ptrd=(BYTE )pd->adr;」は、
ＳＤ両画像共、実操作ポインタを仮引数「TypeArray ps,
TypeArray pd,」から、取り出し変数「BYTE *ptrs;
BYTE *ptrd;」にセット！
「inc_s=ps->inc;inc_d=pd->inc;」は、ＳＤ両画像の
増加幅を高速化する為にローカル変数にセット！
「h=ps->h;v=ps->v;」は、一旦、Ｓ画像の水平幅垂直幅を
取り出し、
「if(h>pd->h){h=pd->h;}」でＤ画像の水平幅との最小値を
有効幅として「h」にセット！
「if(v>pd->v){v=pd->v;}」でＤ画像の垂直幅との最小値を
有効幅として「v」にセット！
「while(--v>=0){・・ループ本体・・}」は、
ループ条件「--v>=0」で垂直幅の数分「ループ本体」を
ループ（繰り返す）処理です★備考★「while(--v>=0」の
様に「--v>=0」とデクリメント演算子で変数値が変化して
も影響が無い応用には、経験上最適なＣＰＵ機械コードが
生成出来るので、この画像処理ライブラリは、この記法を
多用して居ます！学校の教科書的には余り教えて無い（恐ら
く変数の値が変わる事を説明する必要が有るので説明がヤヤ
コシク成る事を嫌ったと推測）と思いますが、兎も角、高速
に動かすには、この記法がベストと考えて採用しています！
ループ条件「--v>=0」で垂直幅の数分繰り返すと言う事は、
水平方向の処理を垂直幅の数分繰り返すとの意味で
ループ本体「BinarizationNonZeoBase(
ptrs,ptrd,h,data);ptrs+=inc_s;ptrd+=inc_d;」は、
水平方向の処理としてサブルーチン
関数「BinarizationNonZeoBase(ptrs,ptrd,h,data);」で
処理し、「ptrs+=inc_s;ptrd+=inc_d;」でポインタを
増加幅分進めるとの意味で次の処理行へ移動との意味です！
勿論、Ｓ画像は「+=inc_s」・Ｄ画像は「+=inc_d」とそれ
ぞれ独立に増加します！
★備考★この様に外側ループで垂直方向を繰り返し「{}」と
ブロック内で水平方向の処理を行うと言う方法は、この画像
処理ライブラリで多用しているアルゴリズムコード記載法で
す！「ptrs+=inc_s;ptrd+=inc_d;」は、次の処理行へ移動と
の意味です！
★備考★この様に外側ループで垂直方向を繰り返し「{}」と
ブロック内で水平方向の処理を行うと言う方法は、
この画像処理ライブラリで多用しているアルゴリズムコード
記載法です！
★注意★順番的に後で解説する事に成りますが、
サブルーチン関数「BinarizationNonZeoBase()」は、
水平方向の処理で「画素≠0」の場合に
仮引数「int data」に画素を置き換える関数です！
「return(END_STI);」は、正常終了を返値として返し
関数終了
（４－１４－１４－Ｅ）関数「BinarizationNonZeo()」の【使用例】説明
{
TypeArray PatImg; // 画像型変数
// ：編か前のパターン画像
TypeArray* pPatImg=&PatImg; // 上記へのポインタ
TypeArray Wimg; // 画像型変数
//：フィル書き込み用
TypeArray* pWimg=&Wimg; // 上記へのポインタ
//：部分画像用
TypeArray* pimgA=&PatImg; // 部分画像用
int sti; // ステータス情報
pPatImg->MallocBYTE( 640, 480 ); // サイズ６４０×４８０画像メモリ取得
FUN.Clear( pPatImg, 0 ); // 画像メモリ「０クリア」
pWimg->MallocBYTE( 640, 480 ); // サイズ６４０×４８０画像メモリ取得
FUN.Clear( pWimg, 0 ); // 画像メモリ「０クリア」
// 典型的な２値化画像生成方法での処理
// サンプルパターン画像作成
pimgA->subset( pPatImg, 100, 200, // 座標範囲（100,200）⇒（149,229）の範囲の
50, 30 ); // 部分画像を用意
FUN.Clear( pimgA, 100 ); // 部分画像を画素データ200でクリア
pimgA->subset( pPatImg, 200, 200, // 座標範囲（100,200）⇒（149,229）の範囲の
30, 50 ); // 部分画像を用意
FUN.Clear( pimgA, 200 ); // 部分画像を画素データ200でクリア
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile9.bmp", pPatImg );
FUN.BinarizationNonZeo( pPatImg, pWimg, t );// 今回紹介する関数「BinarizationNonZeo()」で
// ２値化
//作成した画像をＢＭＰ形式ファイルとして作成
FUN.WriteBitmap("testFile10.bmp", pWimg );
// 後始末
pPatImg->freeMem(); // 画像メモリ解放
pWimg->freeMem(); // 画像メモリ解放
}★注意★
上記例文で注意して欲しいのは、ＬＵＴは、用意して無い事
です！関数「BinarizationNonZeo()」の中でＬＵＴをローカ
ルに使用してＬＵＴ変換を内部で行って居る事です！
更に、黒画素「＝0」・白画素を「≠0」と見なして結果の
白画素を「255」にします！
作成した画像ファイル
取り敢えず、本日（３月２２）の講義は、ココまでにし
ます！何だか、！受講されている方もお疲れと思いますので
ココまでとします！
まだ、Ｎｏｔｅサーバーが快適に動く分量ですから、
引き続き、この文章に続きは、載せます！
２０２４年３月２５続講
（４－１４－１５）関数「void BinarizationXY(
TypeArray* ps,TypeArray* pd,
int x,int y,int h,int v,int t,
int data=255,int low=0);{・・・｝」の説明
void CopyClear::BinarizationXY(
TypeArray* ps, // Ｓ配列（画像）
TypeArray* pd, // Ｄ配列（画像）
int x, // Ｘ座標
int y, // Ｙ座標
int h, // 水平幅
int v, // 垂直幅
int t, // しきい値 0..255
int data, // 出力値：高位（省略時255）
int low // 出力値：低位（省略時０）
){
BYTE* ptrs; // Ｓ画像ポインタ
BYTE* ptrd; // Ｄ画像ポインタ
int incS; // Ｓ増加幅
int incD; // Ｄ増加幅
incS = ps->inc; // Ｓ増加幅を取出
incD = pd->inc; // Ｄ増加幅を取出
ptrs = (BYTE*)ps->adr + x + y * incS; // ＳPtrを取り出し
ptrd = (BYTE*)pd->adr + x + y * incD; // ＤPtrを取り出し
while( --v >= 0 ){ // 垂直方向に繰返し
BinarizationXYBase( ptrs, ptrd, h, // 水平方向処理
t, data, low ); //
ptrs += incS; // 垂直方向に進める
ptrd += incD; // 垂直方向に進める
} //
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
※関数内のコメントに対する備考※「：Ｃ関数専用：」との
記載は、ＰＩＰＬと言うコマンド言語からはアクセス出来る
様に設計して無いとの意味でＣ／Ｃ＋＋で使用する場合は、
普通に使用出来る事を意味します！
（４－１４－１５－Ａ）関数「BinarizationXY()」の【関数名】説明
void CopyClear::BinarizationXY(
TypeArray* ps, // Ｓ配列（画像）
TypeArray* pd, // Ｄ配列（画像）
int x, // Ｘ座標
int y, // Ｙ座標
int h, // 水平幅
int v, // 垂直幅
int t, // しきい値 0..255
int data, // 出力値：高位（省略時255）
int low // 出力値：低位（省略時０）
){「Binarization」は、二値化を意味し、
「XY」は、画像の部分画像を指定して部分画像を処理する
ことを意味します！
（４－１４－１５－Ｂ）関数「void BinarizationXY()」の【返値】説明
void CopyClear::BinarizationXY(
TypeArray* ps, // Ｓ配列（画像）
TypeArray* pd, // Ｄ配列（画像）
int x, // Ｘ座標
int y, // Ｙ座標
int h, // 水平幅
int v, // 垂直幅
int t, // しきい値 0..255
int data, // 出力値：高位（省略時255）
int low // 出力値：低位（省略時０）
){返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（４－１４－１５－Ｃ）関数「BinarizationXY()」の【仮引数】説明
void CopyClear::BinarizationXY(
TypeArray* ps, // Ｓ配列（画像）
TypeArray* pd, // Ｄ配列（画像）
int x, // Ｘ座標
int y, // Ｙ座標
int h, // 水平幅
int v, // 垂直幅
int t, // しきい値 0..255
int data, // 出力値：高位（省略時255）
int low // 出力値：低位（省略時０）
){「TypeArray* ps,」は、Ｓ（元）画像情報
「TypeArray* pd,」は、Ｄ（結果）画像情報
「int x,」は、処理範囲の始点Ｘ座標です
「int y,」は、処理範囲の始点Ｙ座標です
「int h,」は、水平幅＝水平方向の処理サイズです
「int v,」は、垂直幅＝垂直方向の処理サイズです
「int t,」は、閾値（しきい値）と二値の切れ目です！
「int data,」は、白画素の値です！★注意★実引数の
省略時＝２５５と８ビット画像最大値にして居ます！
「int low=0」は、黒画素の値です！★注意★実引数の
省略時＝０と自然数最小値で表示上漆黒にして居ます！
勿論、論理的演算では、「FALSE＝偽」として扱います！
（４－１４－１５－Ｄ）関数「BinarizationXY()」の【アルゴリズム】説明
){
BYTE* ptrs; // Ｓ画像ポインタ
BYTE* ptrd; // Ｄ画像ポインタ
int incS; // Ｓ増加幅
int incD; // Ｄ増加幅
incS = ps->inc; // Ｓ増加幅を取出
incD = pd->inc; // Ｄ増加幅を取出
ptrs = (BYTE*)ps->adr + x + y * incS; // ＳPtrを取り出し
ptrd = (BYTE*)pd->adr + x + y * incD; // ＤPtrを取り出し
while( --v >= 0 ){ // 垂直方向に繰返し
BinarizationXYBase( ptrs, ptrd, h, // 水平方向処理
t, data, low ); //
ptrs += incS; // 垂直方向に進める
ptrd += incD; // 垂直方向に進める
} //
}ローカル変数
){
BYTE* ptrs; // Ｓ画像ポインタ
BYTE* ptrd; // Ｄ画像ポインタ
int incS; // Ｓ増加幅
int incD; // Ｄ増加幅「BYTE *ptrs;」は、Ｓ（元）画像の実操作ポインタです！
「BYTE *ptrd;」は、Ｄ（結果）画像の実操作ポインタ
です！
「int incs;」は、Ｓ（元）画像の増加幅！
「int incd;」は、Ｄ（結果）画像の増加幅！
「int incs;int incd;」は、は、内部で使用し易い（高速化
）の為に内部の単純な変数に画像情報の増加幅を代入した物
です！
アルゴリズムコード
incS = ps->inc; // Ｓ増加幅を取出
incD = pd->inc; // Ｄ増加幅を取出
ptrs = (BYTE*)ps->adr + x + y * incS; // ＳPtrを取り出し
ptrd = (BYTE*)pd->adr + x + y * incD; // ＤPtrを取り出し
while( --v >= 0 ){ // 垂直方向に繰返し
BinarizationXYBase( ptrs, ptrd, h, // 水平方向処理
t, data, low ); //
ptrs += incS; // 垂直方向に進める
ptrd += incD; // 垂直方向に進める
} //
}「incS=ps->inc;incD=pd->inc;」は、ＳＤ両画像の増加幅
を内部変数にセット！
「ptrs=(BYTE )ps->adr+x+yincS;」は、Ｓ画像の実操作
ポインタの初期値として処理始点を計算してセット！
「ptrd=(BYTE )pd->adr+x+yincD;」は、Ｄ画像の実操作
ポインタの初期値として処理始点を計算してセット！
「while(--v>=0){・・ループ本体・・}」は、
ループ条件「--v>=0」で垂直幅の数分「ループ本体」を
ループ（繰り返す）処理です
★備考★「while(--v>=0」の様に「--v>=0」とデクリメント
演算子で変数値が変化しても影響が無い応用には、
経験上最適なＣＰＵ機械コードが生成出来るので、
この画像処理ライブラリは、この記法を多用して居ます！
学校の教科書的には余り教えて無い（恐らく変数の値が変わ
る事を説明する必要が有るので説明がヤヤコシク成る事を
嫌ったと推測）と思いますが、兎も角、高速に動かすには、
この記法がベストと考えて採用しています！
ループ条件「--v>=0」で垂直幅の数分繰り返すと言う事は、
水平方向の処理を垂直幅の数分繰り返すとの意味でループ
本体は、「BinarizationXYBase(ptrs,ptrd,h,t,data,low);
」とサブルーチン「BinarizationXYBase()」で水平方向の
処理を行い、「ptrs+=incS;ptrd+=incD;」でポインタを
増加幅分進めるとの意味で次の処理行へ移動との意味です！
勿論、Ｓ画像は「+=incS」・Ｄ画像は「+=incD」と
それぞれ独立に増加します！
★備考★この様に外側ループで垂直方向を繰り返し「{}」と
ブロック内で水平方向の処理を行うと言う方法は、この画像
処理ライブラリで多用しているアルゴリズムコード記載法で
す！「ptrs+=incS;ptrd+=incD;」は、次の処理行へ移動と
の意味です！
★備考★この様に外側ループで垂直方向を繰り返し「{}」と
ブロック内で水平方向の処理を行うと言う方法は、
この画像処理ライブラリで多用しているアルゴリズムコード
記載法です！
★注意★順番的に後で解説する事に成りますが、
サブルーチン関数「BinarizationXYBase()」は、水平方向の
処理です！
取り敢えず、本日（３月２５）の講義は、ココまでにし
ます！何だか、疲れたのだ！受講されている方もお疲れと
思いますのでココまでとします！
そして、この後は、単なるＬＵＴ変換系で無くカラー画像
に関係する関数を説明するので新しくして！
続きは、「解説クラスＣｏｐｙＣｌｅａｒ（１２）」に
成ります！引き続き御贔屓して受講して下さい！
文末
この記事が気に入ったらサポートをしてみませんか？