解説クラスＣｏｐｙＣｌｅａｒ（３３）
解説クラスＣｏｐｙＣｌｅａｒ（３３）
２０２５年２月２２初稿（初講）
この解説は、膨大なクラス「class CopyClear」の定義を
記載したファイル「CopyClear.h」の順番に従い解説して
行く為に今回は、「private:属性」の関数の説明を行う
事にします！今回は「cvt_byte_b()」関数から説明します！
この解説文章は、
解説『解説クラスＣｏｐｙＣｌｅａｒ（３２）』の続きです
（４－１５－８４）関数「int cvt_byte_b(TypeArray* ps,
TypeArray* pd,BYTE *lut){・・・｝」
/************************************************************************/
/***** ＬＵＴ変換関数（ＬＵＴ＝Byte単位）：Ｓ＝ＢＹＴＥの時 *****/
/***** ＣＯＮＶＥＲＴ，ｓ，ｄ［，ＬＵＴ］ *****/
/************************************************************************/
int CopyClear::cvt_byte_b(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
BYTE *lut // ＬＵＴポインタ
){
short buf_s[ 256 ]; // バッファー
long buf_l[ 256 ]; // バッファー
float buf_f[ 256 ]; // バッファー
double buf_d[ 256 ]; // バッファー
switch( pd->w ){ // Ｄの処理幅が
case 1: // １バイト単位なら
convert_b_b_y( ps, pd, lut ); // 左記でLUT変換
break; //
case 2: // ２バイト単位なら
up_movb2s( lut, buf_s, 256 ); // LUT単位を変換し
convert_b_s_y( ps, pd, buf_s ); // 左記でLUT変換
break; //
case 4: // ４バイト整数か
up_movb2l( lut, buf_l, 256 ); // LUT単位を変換し
convert_b_l_y( ps, pd, buf_l ); // 左記でLUT変換
break; //
case 101: // 単精度単位なら
up_movb2f( lut, buf_f, 256 ); // LUT単位を変換し
convert_b_l_y( ps, pd, (long*)buf_f ); // 左記でLUT変換
break; //
case 102: // 倍精度単位なら
up_movb2d( lut, buf_d, 256 ); // LUT単位を変換し
convert_b_d_y( ps, pd, buf_d ); // 左記でLUT変換
break; //
default: // 上記以外なら
return( STI_ARY_5 - 20 ); // 不正を返す
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「int cvt_byte_b()」の【関数名】
「cvt」は、英単語「Convert」の省略として変換するの
意味です！ここの画像処理では、ＬＵＴ≪ルックアップ
テーブル≫を使用したＳ（元）画像⇒ＬＵＴ変換⇒
Ｄ（結果）画像への画素データをＬＵＴ≪Lookuptable≫
として一時的に変換する技法を使用して変換する関数
です！
「byte」は、勿論、「BYTE型」とＳ（元）画素の単位が、
１バイト無符号を示し、「cvt_byte」で元画像が、
「BYTE型」に成る変換関数です！
★備考★「_」で区切って居るのは、極初期に作成された
ので区切りに「_」を使用するか、単語先頭「英大文字」と
色々迷って居た時期です！
（Ｂ）関数「int cvt_byte_b()」の【返値】
この関数自体でエラーチェックするのは、
仮引数「TypeArray* pd,」詰り、Ｄ（結果）画像画素単位
が、許されている処理単位で無ければ、
エラー「STI_ARY_5-20」と２番の「TypeArray* 」に問題が
有った事を示し、後は、正常終了「END_STI」を関数辺値と
し返し関数終了！
（Ｃ）関数「int cvt_byte_b()」の【仮引数】
int CopyClear::cvt_byte_b(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
BYTE *lut // ＬＵＴポインタ
){「TypeArray* ps,」は、Ｓ（元）画像情報へのポインタを
意味します！
「TypeArray* pd,」は、Ｄ（結果）画像情報への
ポインタを意味します！
「BYTE *lut」は、ＬＵＴの実体へのポインタとして、
この関数では「BYTE *」型、詰り符号無し１バイト単位
です！
（Ｄ）関数「int cvt_byte_b()」の【アルゴリズム】
){
short buf_s[ 256 ]; // バッファー
long buf_l[ 256 ]; // バッファー
float buf_f[ 256 ]; // バッファー
double buf_d[ 256 ]; // バッファー
switch( pd->w ){ // Ｄの処理幅が
case 1: // １バイト単位なら
convert_b_b_y( ps, pd, lut ); // 左記でLUT変換
break; //
case 2: // ２バイト単位なら
up_movb2s( lut, buf_s, 256 ); // LUT単位を変換し
convert_b_s_y( ps, pd, buf_s ); // 左記でLUT変換
break; //
case 4: // ４バイト整数か
up_movb2l( lut, buf_l, 256 ); // LUT単位を変換し
convert_b_l_y( ps, pd, buf_l ); // 左記でLUT変換
break; //
case 101: // 単精度単位なら
up_movb2f( lut, buf_f, 256 ); // LUT単位を変換し
convert_b_l_y( ps, pd, (long*)buf_f ); // 左記でLUT変換
break; //
case 102: // 倍精度単位なら
up_movb2d( lut, buf_d, 256 ); // LUT単位を変換し
convert_b_d_y( ps, pd, buf_d ); // 左記でLUT変換
break; //
default: // 上記以外なら
return( STI_ARY_5 - 20 ); // 不正を返す
} //
return( END_STI ); // 正常終了
}（Ｄ）ローカル変数
){
short buf_s[ 256 ]; // バッファー
long buf_l[ 256 ]; // バッファー
float buf_f[ 256 ]; // バッファー
double buf_d[ 256 ]; // バッファー「short buf_s[256];」は、ローカルバッファー
「long buf_l[256];」は、ローカルバッファー
「float buf_f[256];」は、ローカルバッファー
「double buf_d[256];」は、ローカルバッファー
（Ｄ）アルゴリズムコード
switch( pd->w ){ // Ｄの処理幅が
case 1: // １バイト単位なら
convert_b_b_y( ps, pd, lut ); // 左記でLUT変換
break; //
case 2: // ２バイト単位なら
up_movb2s( lut, buf_s, 256 ); // LUT単位を変換し
convert_b_s_y( ps, pd, buf_s ); // 左記でLUT変換
break; //
case 4: // ４バイト整数か
up_movb2l( lut, buf_l, 256 ); // LUT単位を変換し
convert_b_l_y( ps, pd, buf_l ); // 左記でLUT変換
break; //
case 101: // 単精度単位なら
up_movb2f( lut, buf_f, 256 ); // LUT単位を変換し
convert_b_l_y( ps, pd, (long*)buf_f ); // 左記でLUT変換
break; //
case 102: // 倍精度単位なら
up_movb2d( lut, buf_d, 256 ); // LUT単位を変換し
convert_b_d_y( ps, pd, buf_d ); // 左記でLUT変換
break; //
default: // 上記以外なら
return( STI_ARY_5 - 20 ); // 不正を返す
} //
return( END_STI ); // 正常終了
}概要「switch(pd->w){・・ｓｗｉｔｃｈ分岐本体・・}」で
Ｄ（結果）画像の画素単位が
「case 1:convert_b_b_y(ps,pd,lut);break;」と１バイト
整数型ならば、「convert_b_b_y(ps,pd,lut);break;」で
サブルーチン関数「convert_b_b_y()」で処理し
「case 2:up_movb2s(lut,buf_s,256);
convert_b_s_y(ps,pd,buf_s);break;」と２バイト
整数型ならば、「up_movb2s(lut,buf_s,256);」で
バッファー「short buf_s[256];」へコピーし
サブルーチン関数「convert_b_s_y()」で処理し
「case 4:up_movb2l(lut,buf_l,256);
convert_b_l_y(ps,pd,buf_l);」と４バイト
整数型ならば、「up_movb2l(lut,buf_l,256);」で
バッファー「long buf_l[256];」へコピーし
サブルーチン関数「convert_b_l_y()」で処理し
「case 101:up_movb2f(lut,buf_f,256);
convert_b_l_y(ps,pd,(long*)buf_f);」単精度浮動小数点
型ならば、「up_movb2f(lut,buf_f,256);」で
バッファー「float buf_f[256];」へコピーし
サブルーチン関数「convert_b_l_y()」で処理し★備考★
「long型」も「float型」も同じ４サイズの処理系が前提！
「case 101:up_movb2f(lut,buf_f,256);
convert_b_l_y(ps,pd,(long*)buf_f);」単精度浮動小数点
型ならば、「up_movb2f(lut,buf_f,256);」で
バッファー「float buf_f[256];」へコピーし
サブルーチン関数「convert_b_l_y()」で処理し★備考★
「long型」も「float型」も同じ４サイズの処理系が前提！
「case 102:up_movb2d(lut,buf_d,256);
convert_b_d_y(ps,pd,buf_d);」と倍精度浮動小数点型なら
ば、「up_movb2d(lut,buf_d,256);」で
バッファー「double buf_d[256];」へコピーし
サブルーチン関数「convert_b_d_y()」で処理し
「default:return(STI_ARY_5-20);」と指定外ならば、
エラーコード「STI_ARY_5-20」を関数辺値とし返し関数終了
「return(END_STI);」は、正常終了「END_STI」を関数辺値
とし返し関数終了！
（４－１５－８５）関数「int cvt_byte_w(TypeArray* ps,
TypeArray* pd,BYTE *lut){・・・｝」
/************************************************************************/
/***** ＬＵＴ変換関数（ＬＵＴ＝Byte単位）：Ｓ＝ＷＯＲＤの時 *****/
/***** ＣＯＮＶＥＲＴ，ｓ，ｄ［，ＬＵＴ］ *****/
/************************************************************************/
int CopyClear::cvt_byte_w(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
BYTE *lut // ＬＵＴポインタ
){
short *bufs; // バッファー:short
long *bufl; // バッファー:long
float *buff; // バッファー:float
double *bufd; // バッファー:double
switch( pd->w ){ // Ｄの処理幅が
case 1: // １バイト単位なら
convert_w_b_y( ps, pd, lut ); // 左記でLUT変換
break; //
case 2: // ２バイト単位なら
bufs = (short*)malloc( sizeof(short) * 65536 ); // メモリ確保
if( bufs == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movb2s( lut, bufs, 65536 ); // LUT単位を変換し
convert_w_s_y( ps, pd, bufs ); // 左記でLUT変換
free( bufs ); // メモリ解放し
break; //
case 4: // ４バイト整数か
bufl = (long*)malloc( sizeof(long) * 65536 ); // メモリ確保
if( bufl == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movb2l( lut, bufl, 65536 ); // LUT単位を変換し
convert_w_l_y( ps, pd, bufl ); // 左記でLUT変換
free( bufl ); // メモリ解放し
break; //
case 101: // 単精度単位なら
buff = (float*)malloc( sizeof(float) * 65536 ); // メモリ確保
if( buff == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movb2f( lut, buff, 65536 ); // LUT単位を変換し
convert_w_l_y( ps, pd, (long*)buff ); // 左記でLUT変換
free( buff ); // メモリ解放し
break; //
case 102: // 倍精度単位なら
bufd = (double*)malloc( sizeof(double) * 65536 ); // メモリ確保
if( bufd == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movb2d( lut, bufd, 65536 ); // LUT単位を変換し
convert_w_d_y( ps, pd, bufd ); // 左記でLUT変換
free( bufd ); // メモリ解放し
break; //
default: // 上記以外なら
return( STI_ARY_5 - 20 ); // 不正を返す
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「int cvt_byte_w()」の【関数名】
「cvt」は、英単語「Convert」の省略として変換するの
意味です！ここの画像処理では、ＬＵＴ≪ルックアップ
テーブル≫を使用したＳ（元）画像⇒ＬＵＴ変換⇒
Ｄ（結果）画像への画素データをＬＵＴ≪Lookuptable≫
として一時的に変換する技法を使用して変換する関数
です！
「w」は、勿論、「short型」とＳ（元）画素の単位が、
２バイトを示し、「cvt_byte」で結果画像が、「BYTE型」
と同じく「0..255」に成る変換関数です！
★備考★「」で区切って居るのは、極初期に作成された
ので区切りに「_」を使用するか、単語先頭「英大文字」と
色々迷って居た時期です！
（Ｂ）関数「int cvt_byte_w()」の【返値】
この関数自体でエラーチェックするのは、
仮引数「TypeArray* pd,」詰り、Ｄ（結果）画像画素単位
が、許されている処理単位で無ければ、
エラー「STI_ARY_5-20」と２番の「TypeArray* 」に問題が
有った事を示し、後は、正常終了「END_STI」を関数辺値と
し返し関数終了！
（Ｃ）関数「int cvt_byte_w()」の【仮引数】
int CopyClear::cvt_byte_w(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
BYTE *lut // ＬＵＴポインタ
){「TypeArray* ps,」は、Ｓ（元）画像情報へのポインタを
意味します！
「TypeArray* pd,」は、Ｄ（結果）画像情報への
ポインタを意味します！
「BYTE *lut」は、ＬＵＴの実体へのポインタとして、
この関数では「BYTE *」型、詰り符号無し１バイト単位
です！
（Ｄ）関数「int cvt_byte_w()」の【アルゴリズム】
){
short *bufs; // バッファー:short
long *bufl; // バッファー:long
float *buff; // バッファー:float
double *bufd; // バッファー:double
switch( pd->w ){ // Ｄの処理幅が
case 1: // １バイト単位なら
convert_w_b_y( ps, pd, lut ); // 左記でLUT変換
break; //
case 2: // ２バイト単位なら
bufs = (short*)malloc( sizeof(short) * 65536 ); // メモリ確保
if( bufs == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movb2s( lut, bufs, 65536 ); // LUT単位を変換し
convert_w_s_y( ps, pd, bufs ); // 左記でLUT変換
free( bufs ); // メモリ解放し
break; //
case 4: // ４バイト整数か
bufl = (long*)malloc( sizeof(long) * 65536 ); // メモリ確保
if( bufl == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movb2l( lut, bufl, 65536 ); // LUT単位を変換し
convert_w_l_y( ps, pd, bufl ); // 左記でLUT変換
free( bufl ); // メモリ解放し
break; //
case 101: // 単精度単位なら
buff = (float*)malloc( sizeof(float) * 65536 ); // メモリ確保
if( buff == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movb2f( lut, buff, 65536 ); // LUT単位を変換し
convert_w_l_y( ps, pd, (long*)buff ); // 左記でLUT変換
free( buff ); // メモリ解放し
break; //
case 102: // 倍精度単位なら
bufd = (double*)malloc( sizeof(double) * 65536 ); // メモリ確保
if( bufd == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movb2d( lut, bufd, 65536 ); // LUT単位を変換し
convert_w_d_y( ps, pd, bufd ); // 左記でLUT変換
free( bufd ); // メモリ解放し
break; //
default: // 上記以外なら
return( STI_ARY_5 - 20 ); // 不正を返す
} //
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
short *bufs; // バッファー:short
long *bufl; // バッファー:long
float *buff; // バッファー:float
double *bufd; // バッファー:double「short *bufs;」は、ローカルバッファーへのPtr
「long *bufl;」は、ローカルバッファーへのPtr
「float *buff;」は、ローカルバッファーへのPtr
「double* bufd;」は、ローカルバッファーへのPtr
（Ｄ―２）アルゴリズムコード
switch( pd->w ){ // Ｄの処理幅が
case 1: // １バイト単位なら
convert_w_b_y( ps, pd, lut ); // 左記でLUT変換
break; //
case 2: // ２バイト単位なら
bufs = (short*)malloc( sizeof(short) * 65536 ); // メモリ確保
if( bufs == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movb2s( lut, bufs, 65536 ); // LUT単位を変換し
convert_w_s_y( ps, pd, bufs ); // 左記でLUT変換
free( bufs ); // メモリ解放し
break; //
case 4: // ４バイト整数か
bufl = (long*)malloc( sizeof(long) * 65536 ); // メモリ確保
if( bufl == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movb2l( lut, bufl, 65536 ); // LUT単位を変換し
convert_w_l_y( ps, pd, bufl ); // 左記でLUT変換
free( bufl ); // メモリ解放し
break; //
case 101: // 単精度単位なら
buff = (float*)malloc( sizeof(float) * 65536 ); // メモリ確保
if( buff == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movb2f( lut, buff, 65536 ); // LUT単位を変換し
convert_w_l_y( ps, pd, (long*)buff ); // 左記でLUT変換
free( buff ); // メモリ解放し
break; //
case 102: // 倍精度単位なら
bufd = (double*)malloc( sizeof(double) * 65536 ); // メモリ確保
if( bufd == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movb2d( lut, bufd, 65536 ); // LUT単位を変換し
convert_w_d_y( ps, pd, bufd ); // 左記でLUT変換
free( bufd ); // メモリ解放し
break; //
default: // 上記以外なら
return( STI_ARY_5 - 20 ); // 不正を返す
} //
return( END_STI ); // 正常終了
}概要「switch(pd->w){・・ｓｗｉｔｃｈ分岐本体・・}」で
Ｄ（結果）画像の画素単位が
「case 1:convert_w_b_y(ps,pd,lut);break;」と１バイト
整数型ならば、「convert_w_b_y(ps,pd,lut);break;」で
サブルーチン関数「convert_b_b_y()」で処理し
「case 2:bufs=(short)malloc(sizeof(short)*65536);
if(bufs==0){return(STI_MEM);}
up_movb2s(lut,bufs,65536);
convert_w_s_y(ps,pd,bufs);
free(bufs);break;」と２バイト整数型ならば、
「bufs=(short)malloc(sizeof(short)*65536);
if(bufs==0){return(STI_MEM);}」と６５５３６サイズの
バッファーを用意★備考★昔は６５５３６サイズの配列で
確保する事がコンパイルシステムで許可出来無かった
システムが多かったのです！
「if(bufs==0){return(STI_MEM);}」でメモリ確保失敗時は
エラーコード「STI_MEM」を関数辺値とし返し関数終了！
「up_movb2s(lut,bufs,65536);
convert_w_s_y(ps,pd,bufs);
free(bufs);break;」とバッファー「short bufs;」に
コピーし、「convert_w_s_y(ps,pd,bufs)」でＬＵＴ変換
サブルーチン関数「convert_w_s_y()」で処理し
「free(bufs);」でメモリ確保の後始末でのメモリ解放！
「case4:bufl=(long)malloc(sizeof(long)*65536);
if(bufs==0){return(STI_MEM);}
up_movb2l(lut,bufl,65536);
convert_w_l_y(ps,pd,bufs);
free(bufl);break;」と４バイト整数型ならば、
「bufl=(long)malloc(sizeof(long)*65536);
if(bufl==0){return(STI_MEM);}」と６５５３６サイズの
バッファーを用意★備考★昔は６５５３６サイズの配列で
確保する事がコンパイルシステムで許可出来無かった
システムが多かったのです！
「if(bufl==0){return(STI_MEM);}」でメモリ確保失敗時は
エラーコード「STI_MEM」を関数辺値とし返し関数終了！
「up_movb2l(lut,bufl,65536);
convert_w_l_y(ps,pd,bufl);
free(bufl);break;」とバッファー「long bufl;」に
コピーし、「convert_w_l_y(ps,pd,bufl)」でＬＵＴ変換
サブルーチン関数「convert_w_l_y()」で処理し
「free(bufl);」でメモリ確保の後始末でのメモリ解放！
「case101:buff=(float)malloc(sizeof(float)*65536);
if(bufs==0){return(STI_MEM);}
up_movb2f(lut,buff,65536);
convert_w_l_y(ps,pd,bufs);
free(buff);break;」と単精度浮動小数点型ならば、
「buff=(float)malloc(sizeof(float)*65536);
if(buff==0){return(STI_MEM);}」と６５５３６サイズの
バッファーを用意★備考★昔は６５５３６サイズの配列で
確保する事がコンパイルシステムで許可出来無かった
システムが多かったのです！
「if(buff==0){return(STI_MEM);}」でメモリ確保失敗時は
エラーコード「STI_MEM」を関数辺値とし返し関数終了！
「up_movb2f(lut,buff,65536);
convert_w_l_y(ps,pd,(long)buff);
free(buff);break;」とバッファー「float buff;」に
コピーし、「convert_w_l_y(ps,pd,(long)buff)」で
ＬＵＴ変換★備考★「long型」と「float型」が同じく
４バイトサイズで有る事が条件の処理系
サブルーチン関数「convert_w_l_y()」で処理し
「free(buff);」でメモリ確保の後始末でのメモリ解放！
「case102:bufd=(double)malloc(sizeof(double)*65536);
if(bufs==0){return(STI_MEM);}
up_movb2f(lut,bufd,65536);
convert_w_d_y(ps,pd,bufs);
free(bufd);break;」と倍精度浮動小数点型ならば、
「bufd=(double)malloc(sizeof(double)*65536);
if(bufd==0){return(STI_MEM);}」と６５５３６サイズの
バッファーを用意★備考★昔は６５５３６サイズの配列で
確保する事がコンパイルシステムで許可出来無かった
システムが多かったのです！
「if(bufd==0){return(STI_MEM);}」でメモリ確保失敗時は
エラーコード「STI_MEM」を関数辺値とし返し関数終了！
「up_movb2f(lut,bufd,65536);
convert_w_d_y(ps,pd,bufd);
free(bufd);break;」とバッファー「double bufd;」に
コピーし、「convert_w_d_y(ps,pd,(long)*bufd)」で
ＬＵＴ変換、サブルーチン関数「convert_w_d_y()」で処理
し、「free(bufd);」でメモリ確保の後始末でのメモリ
解放！
「default:return(STI_ARY_5-20);」と指定外ならば、
エラーコード「STI_ARY_5-20」を関数辺値とし返し関数終了
「return(END_STI);」は、正常終了「END_STI」を関数辺値
とし返し関数終了！
（４－１５－８６）関数「int cvt_word_b(TypeArray* ps,
TypeArray* pd,short*lut){・・・｝」
/************************************************************************/
/***** ＬＵＴ変換関数（ＬＵＴ＝WORD単位）：Ｓ＝ＢＹＴＥの時 *****/
/***** ＣＯＮＶＥＲＴ，ｓ，ｄ［，ＬＵＴ］ *****/
/************************************************************************/
int CopyClear::cvt_word_b(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
short *lut // ＬＵＴポインタ
){
BYTE buf_b[ 256 ]; // バッファー
long buf_l[ 256 ]; // バッファー
float buf_f[ 256 ]; // バッファー
double buf_d[ 256 ]; // バッファー
switch( pd->w ){ // Ｄの処理幅が
case 1: // １バイト単位なら
up_movs2b( lut, buf_b, 256 ); // LUT単位を変換し
convert_b_b_y( ps, pd, buf_b ); // 左記でLUT変換
break; //
case 2: // ２バイト単位なら
convert_b_s_y( ps, pd, lut ); // 左記でLUT変換
break; //
case 4: // ４バイト整数か
up_movs2l( lut, buf_l, 256 ); // LUT単位を変換し
convert_b_l_y( ps, pd, buf_l ); // 左記でLUT変換
break; //
case 101: // 単精度単位なら
up_movs2f( lut, buf_f, 256 ); // LUT単位を変換し
convert_b_l_y( ps, pd, (long*)buf_f ); // 左記でLUT変換
break; //
case 102: // 倍精度単位なら
up_movs2d( lut, buf_d, 256 ); // LUT単位を変換し
convert_b_d_y( ps, pd, buf_d ); // 左記でLUT変換
break; //
default: // 上記以外なら
return( STI_ARY_5 - 20 ); // 不正を返す
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「int cvt_word_b()」の【関数名】
「cvt」は、英単語「Convert」の省略として変換するの
意味です！ここの画像処理では、ＬＵＴ≪ルックアップ
テーブル≫を使用したＳ（元）画像⇒ＬＵＴ変換⇒
Ｄ（結果）画像への画素データをＬＵＴ≪Lookuptable≫
として一時的に変換する技法を使用して変換する関数
です！
「b」は、勿論、「BYTE型」とＳ（元）画素の単位が、
１バイトを示し、「cvt_word」で結果画像が、「short型」
と同じく「-32768..0..32767」に成る変換関数です！
★備考★「_」で区切って居るのは、極初期に作成された
ので区切りに「_」を使用するか、単語先頭「英大文字」と
色々迷って居た時期です！
（Ｂ）関数「int cvt_word_b()」の【返値】
この関数自体でエラーチェックするのは、
仮引数「TypeArray* pd,」詰り、Ｄ（結果）画像画素単位
が、許されている処理単位で無ければ、
エラー「STI_ARY_5-20」と２番の「TypeArray* 」に問題が
有った事を示し、後は、正常終了「END_STI」を関数辺値と
し返し関数終了！
（Ｃ）関数「int cvt_word_b()」の【仮引数】
int CopyClear::cvt_word_b(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
short *lut // ＬＵＴポインタ
){「TypeArray* ps,」は、Ｓ（元）画像情報へのポインタを
意味します！
「TypeArray* pd,」は、Ｄ（結果）画像情報への
ポインタを意味します！
「short* lut」は、ＬＵＴの実体へのポインタとして、
この関数では「short」型、詰り符号有り２バイト単位
です！
（Ｄ）関数「int cvt_word_b()」の【アルゴリズム】
){
BYTE buf_b[ 256 ]; // バッファー
long buf_l[ 256 ]; // バッファー
float buf_f[ 256 ]; // バッファー
double buf_d[ 256 ]; // バッファー
switch( pd->w ){ // Ｄの処理幅が
case 1: // １バイト単位なら
up_movs2b( lut, buf_b, 256 ); // LUT単位を変換し
convert_b_b_y( ps, pd, buf_b ); // 左記でLUT変換
break; //
case 2: // ２バイト単位なら
convert_b_s_y( ps, pd, lut ); // 左記でLUT変換
break; //
case 4: // ４バイト整数か
up_movs2l( lut, buf_l, 256 ); // LUT単位を変換し
convert_b_l_y( ps, pd, buf_l ); // 左記でLUT変換
break; //
case 101: // 単精度単位なら
up_movs2f( lut, buf_f, 256 ); // LUT単位を変換し
convert_b_l_y( ps, pd, (long*)buf_f ); // 左記でLUT変換
break; //
case 102: // 倍精度単位なら
up_movs2d( lut, buf_d, 256 ); // LUT単位を変換し
convert_b_d_y( ps, pd, buf_d ); // 左記でLUT変換
break; //
default: // 上記以外なら
return( STI_ARY_5 - 20 ); // 不正を返す
} //
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
「BYTE buf_b[256];」は、ローカルバッファー
「long buf_l[256];」は、ローカルバッファー
「float buf_f[256];」は、ローカルバッファー
「double buf_d[256];」は、ローカルバッファー
（Ｄ―２）アルゴリズムコード
switch( pd->w ){ // Ｄの処理幅が
case 1: // １バイト単位なら
up_movs2b( lut, buf_b, 256 ); // LUT単位を変換し
convert_b_b_y( ps, pd, buf_b ); // 左記でLUT変換
break; //
case 2: // ２バイト単位なら
convert_b_s_y( ps, pd, lut ); // 左記でLUT変換
break; //
case 4: // ４バイト整数か
up_movs2l( lut, buf_l, 256 ); // LUT単位を変換し
convert_b_l_y( ps, pd, buf_l ); // 左記でLUT変換
break; //
case 101: // 単精度単位なら
up_movs2f( lut, buf_f, 256 ); // LUT単位を変換し
convert_b_l_y( ps, pd, (long*)buf_f ); // 左記でLUT変換
break; //
case 102: // 倍精度単位なら
up_movs2d( lut, buf_d, 256 ); // LUT単位を変換し
convert_b_d_y( ps, pd, buf_d ); // 左記でLUT変換
break; //
default: // 上記以外なら
return( STI_ARY_5 - 20 ); // 不正を返す
} //
return( END_STI ); // 正常終了
}概要「switch(pd->w){・・ｓｗｉｔｃｈ分岐本体・・}」で
Ｄ（結果）画像の画素単位が
「case 1:up_movs2b(lut,buf_b,256);
convert_b_b_y(ps,pd,buf_b);break;」と１バイト
整数型ならば、「up_movs2b(lut,buf_b,256);」で
バッファー「short buf_b[256];」へコピーし
「convert_b_b_y(ps,pd,buf_b);break;」で
サブルーチン関数「convert_b_b_y()」で処理し
「case 2:convert_b_s_y(ps,pd,lut);break;」と２バイト
整数型ならば、サブルーチン関数「convert_b_s_y()」で
処理し
「case 4:up_movs2l(lut,buf_l,256);
convert_b_l_y(ps,pd,buf_l);」と４バイト
整数型ならば、「up_movs2l(lut,buf_l,256);」で
バッファー「long buf_l[256];」へコピーし
サブルーチン関数「convert_b_l_y()」で処理し
「case 101:up_movs2f(lut,buf_f,256);
convert_b_l_y(ps,pd,(long*)buf_f);」単精度浮動小数点
型ならば、「up_movs2f(lut,buf_f,256);」で
バッファー「float buf_f[256];」へコピーし
サブルーチン関数「convert_b_l_y()」で処理し★備考★
「long型」も「float型」も同じ４サイズの処理系が前提！
「case 102:up_movs2d(lut,buf_d,256);
convert_b_d_y(ps,pd,buf_d);」と倍精度浮動小数点型なら
ば、「up_movs2d(lut,buf_d,256);」で
バッファー「double buf_d[256];」へコピーし
サブルーチン関数「convert_b_d_y()」で処理し
「default:return(STI_ARY_5-20);」と指定外ならば、
エラーコード「STI_ARY_5-20」を関数辺値とし返し関数終了
「return(END_STI);」は、正常終了「END_STI」を関数辺値
とし返し関数終了！
（４－１５－８７）関数「int cvt_word_w(
TypeArray* ps,
TypeArray* pd,short* lut){・・・｝」
/************************************************************************/
/***** ＬＵＴ変換関数（ＬＵＴ＝WORD単位）：Ｓ＝ＷＯＲＤの時 *****/
/***** ＣＯＮＶＥＲＴ，ｓ，ｄ［，ＬＵＴ］ *****/
/************************************************************************/
int CopyClear::cvt_word_w(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
short *lut // ＬＵＴポインタ
){
BYTE *bufb; // バッファー:BYTE
long *bufl; // バッファー:long
float *buff; // バッファー:float
double *bufd; // バッファー:double
switch( pd->w ){ // Ｄの処理幅が
case 1: // １バイト単位なら
bufb = (BYTE*)malloc( sizeof(BYTE) * 65536 ); // メモリ確保
if( bufb == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movs2b( lut, bufb, 65536 ); // LUT単位を変換し
convert_w_b_y( ps, pd, bufb ); // 左記でLUT変換
free( bufb ); // メモリ解放し
break; //
case 2: // ２バイト単位なら
convert_w_s_y( ps, pd, lut ); // 左記でLUT変換
break; //
case 4: // ４バイト整数か
bufl = (long*)malloc( sizeof(long) * 65536 ); // メモリ確保
if( bufl == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movs2l( lut, bufl, 65536 ); // LUT単位を変換し
convert_w_l_y( ps, pd, bufl ); // 左記でLUT変換
free( bufl ); // メモリ解放し
break; //
case 101: // 単精度単位なら
buff = (float*)malloc( sizeof(float) * 65536 ); // メモリ確保
if( buff == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movs2f( lut, buff, 65536 ); // LUT単位を変換し
convert_w_l_y( ps, pd, (long*)buff ); // 左記でLUT変換
free( buff ); // メモリ解放し
break; //
case 102: // 倍精度単位なら
bufd = (double*)malloc( sizeof(double) * 65536 ); // メモリ確保
if( bufd == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movs2d( lut, bufd, 65536 ); // LUT単位を変換し
convert_w_d_y( ps, pd, bufd ); // 左記でLUT変換
free( bufd ); // メモリ解放し
break; //
default: // 上記以外なら
return( STI_ARY_5 - 20 ); // 不正を返す
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「int cvt_word_w()」の【関数名】
「cvt」は、英単語「Convert」の省略として変換するの
意味です！ここの画像処理では、ＬＵＴ≪ルックアップ
テーブル≫を使用したＳ（元）画像⇒ＬＵＴ変換⇒
Ｄ（結果）画像への画素データをＬＵＴ≪Lookuptable≫
として一時的に変換する技法を使用して変換する関数
です！
「w」は、勿論、「UWORD型」とＳ（元）画素の単位が、
２バイトを示し、「cvt_word」で結果画像が、「short型」
と同じく「-32768..0..32767」に成る変換関数です！
★備考★「_」で区切って居るのは、極初期に作成された
ので区切りに「_」を使用するか、単語先頭「英大文字」と
色々迷って居た時期です！
（Ｂ）関数「int cvt_word_w()」の【返値】
この関数自体でエラーチェックするのは、
仮引数「TypeArray* pd,」詰り、Ｄ（結果）画像画素単位
が、許されている処理単位で無ければ、
エラー「STI_ARY_5-20」と２番の「TypeArray* 」に問題が
有った事を示し、後は、正常終了「END_STI」を関数辺値と
し返し関数終了！
（Ｃ）関数「int cvt_word_w()」の【仮引数】
int CopyClear::cvt_word_w(
TypeArray *ps, // Ｓ配列
TypeArray *pd, // Ｄ配列
short *lut // ＬＵＴポインタ
){「TypeArray* ps,」は、Ｓ（元）画像情報へのポインタを
意味します！
「TypeArray* pd,」は、Ｄ（結果）画像情報への
ポインタを意味します！
「short *lut」は、ＬＵＴの実体へのポインタとして、
この関数では「short 」型、詰り符号有り２バイト単位
です！
（Ｄ）関数「int cvt_word_w()」の【アルゴリズム】
){
BYTE *bufb; // バッファー:BYTE
long *bufl; // バッファー:long
float *buff; // バッファー:float
double *bufd; // バッファー:double
switch( pd->w ){ // Ｄの処理幅が
case 1: // １バイト単位なら
bufb = (BYTE*)malloc( sizeof(BYTE) * 65536 ); // メモリ確保
if( bufb == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movs2b( lut, bufb, 65536 ); // LUT単位を変換し
convert_w_b_y( ps, pd, bufb ); // 左記でLUT変換
free( bufb ); // メモリ解放し
break; //
case 2: // ２バイト単位なら
convert_w_s_y( ps, pd, lut ); // 左記でLUT変換
break; //
case 4: // ４バイト整数か
bufl = (long*)malloc( sizeof(long) * 65536 ); // メモリ確保
if( bufl == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movs2l( lut, bufl, 65536 ); // LUT単位を変換し
convert_w_l_y( ps, pd, bufl ); // 左記でLUT変換
free( bufl ); // メモリ解放し
break; //
case 101: // 単精度単位なら
buff = (float*)malloc( sizeof(float) * 65536 ); // メモリ確保
if( buff == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movs2f( lut, buff, 65536 ); // LUT単位を変換し
convert_w_l_y( ps, pd, (long*)buff ); // 左記でLUT変換
free( buff ); // メモリ解放し
break; //
case 102: // 倍精度単位なら
bufd = (double*)malloc( sizeof(double) * 65536 ); // メモリ確保
if( bufd == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movs2d( lut, bufd, 65536 ); // LUT単位を変換し
convert_w_d_y( ps, pd, bufd ); // 左記でLUT変換
free( bufd ); // メモリ解放し
break; //
default: // 上記以外なら
return( STI_ARY_5 - 20 ); // 不正を返す
} //
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
BYTE *bufb; // バッファー:BYTE
long *bufl; // バッファー:long
float *buff; // バッファー:float
double *bufd; // バッファー:double「BYTE *bufb;」は、ローカルバッファーへのPtr
「long *bufl;」は、ローカルバッファーへのPtr
「float *buff;」は、ローカルバッファーへのPtr
「double* bufd;」は、ローカルバッファーへのPtr
（Ｄ―２）アルゴリズムコード
switch( pd->w ){ // Ｄの処理幅が
case 1: // １バイト単位なら
bufb = (BYTE*)malloc( sizeof(BYTE) * 65536 ); // メモリ確保
if( bufb == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movs2b( lut, bufb, 65536 ); // LUT単位を変換し
convert_w_b_y( ps, pd, bufb ); // 左記でLUT変換
free( bufb ); // メモリ解放し
break; //
case 2: // ２バイト単位なら
convert_w_s_y( ps, pd, lut ); // 左記でLUT変換
break; //
case 4: // ４バイト整数か
bufl = (long*)malloc( sizeof(long) * 65536 ); // メモリ確保
if( bufl == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movs2l( lut, bufl, 65536 ); // LUT単位を変換し
convert_w_l_y( ps, pd, bufl ); // 左記でLUT変換
free( bufl ); // メモリ解放し
break; //
case 101: // 単精度単位なら
buff = (float*)malloc( sizeof(float) * 65536 ); // メモリ確保
if( buff == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movs2f( lut, buff, 65536 ); // LUT単位を変換し
convert_w_l_y( ps, pd, (long*)buff ); // 左記でLUT変換
free( buff ); // メモリ解放し
break; //
case 102: // 倍精度単位なら
bufd = (double*)malloc( sizeof(double) * 65536 ); // メモリ確保
if( bufd == 0 ){ // 失敗時
return( STI_MEM ); // 左記を返す
} //
up_movs2d( lut, bufd, 65536 ); // LUT単位を変換し
convert_w_d_y( ps, pd, bufd ); // 左記でLUT変換
free( bufd ); // メモリ解放し
break; //
default: // 上記以外なら
return( STI_ARY_5 - 20 ); // 不正を返す
} //
return( END_STI ); // 正常終了
}概要「switch(pd->w){・・ｓｗｉｔｃｈ分岐本体・・}」で
Ｄ（結果）画像の画素単位が
「case 1:bufb=(BYTE)malloc(sizeof(BYTE)*65536);
if(bufb==0){return(STI_MEM);}
up_movs2b(lut,bufb,65536);
bufb=(BYTE)malloc(sizeof(BYTE)*65536);
convert_w_b_y(ps,pd,bufb);free(bufb);break;」と
１バイト整数型ならば、６５５３６サイズの
バッファーを用意★備考★昔は６５５３６サイズの配列で
確保する事がコンパイルシステムで許可出来無かった
システムが多かったのです！
「if(bufb==0){return(STI_MEM);}
up_movs2b(lut,bufb,65536);
convert_w_b_y(ps,pd,bufb);free(bufb);break;」と
「if(bufb==0){return(STI_MEM);}」でメモリ確保失敗時は
エラーコード「STI_MEM」を関数辺値とし返し関数終了！
「up_movb2s(lut,bufb,65536);
convert_w_s_y(ps,pd,bufb);
free(bufb);break;」とバッファー「short bufb;」に
コピーし、「convert_w_s_y(ps,pd,bufb)」でＬＵＴ変換
サブルーチン関数「convert_w_s_y()」で処理し
「free(bufb);」でメモリ確保の後始末でのメモリ解放！
「case 2:convert_w_s_y(ps,pd,lut);break;」と２バイト
整数型ならば、サブルーチン関数「convert_w_s_y()」で
ＬＵＴ変換
「case4:bufl=(long)malloc(sizeof(long)*65536);
if(bufｌ==0){return(STI_MEM);}
up_movb2l(lut,bufl,65536);
convert_w_l_y(ps,pd,bufｌ);
free(bufl);break;」と４バイト整数型ならば、
「bufl=(long)malloc(sizeof(long)*65536);
if(bufl==0){return(STI_MEM);}」と６５５３６サイズの
バッファーを用意★備考★昔は６５５３６サイズの配列で
確保する事がコンパイルシステムで許可出来無かった
システムが多かったのです！
「if(bufl==0){return(STI_MEM);}」でメモリ確保失敗時は
エラーコード「STI_MEM」を関数辺値とし返し関数終了！
「up_movb2l(lut,bufl,65536);
convert_w_l_y(ps,pd,bufl);
free(bufl);break;」とバッファー「long bufl;」に
コピーし、「convert_w_l_y(ps,pd,bufl)」でＬＵＴ変換
サブルーチン関数「convert_w_l_y()」で処理し
「free(bufl);」でメモリ確保の後始末でのメモリ解放！
「case101:buff=(float)malloc(sizeof(float)*65536);
if(buff==0){return(STI_MEM);}
up_movb2f(lut,buff,65536);
convert_w_l_y(ps,pd,(long)buff);
free(buff);break;」と単精度浮動小数点型ならば、
「buff=(float)malloc(sizeof(float)*65536);
if(buff==0){return(STI_MEM);}」と６５５３６サイズの
バッファーを用意★備考★昔は６５５３６サイズの配列で
確保する事がコンパイルシステムで許可出来無かった
システムが多かったのです！
「if(buff==0){return(STI_MEM);}」でメモリ確保失敗時は
エラーコード「STI_MEM」を関数辺値とし返し関数終了！
「up_movb2f(lut,buff,65536);
convert_w_l_y(ps,pd,(long)buff);
free(buff);break;」とバッファー「float buff;」に
コピーし、「convert_w_l_y(ps,pd,(long)buff)」で
ＬＵＴ変換★備考★「long型」と「float型」が同じく
４バイトサイズで有る事が条件の処理系
サブルーチン関数「convert_w_l_y()」で処理し
「free(buff);」でメモリ確保の後始末でのメモリ解放！
「case102:bufd=(double)malloc(sizeof(double)*65536);
if(bufs==0){return(STI_MEM);}
up_movb2f(lut,bufd,65536);
convert_w_d_y(ps,pd,bufs);
free(bufd);break;」と倍精度浮動小数点型ならば、
「bufd=(double)malloc(sizeof(double)*65536);
if(bufd==0){return(STI_MEM);}」と６５５３６サイズの
バッファーを用意★備考★昔は６５５３６サイズの配列で
確保する事がコンパイルシステムで許可出来無かった
システムが多かったのです！
「if(bufd==0){return(STI_MEM);}」でメモリ確保失敗時は
エラーコード「STI_MEM」を関数辺値とし返し関数終了！
「up_movb2f(lut,bufd,65536);
convert_w_d_y(ps,pd,bufd);
free(bufd);break;」とバッファー「double bufd;」に
コピーし、「convert_w_d_y(ps,pd,(long)bufd)」で
ＬＵＴ変換、サブルーチン関数「convert_w_d_y()」で処理
し、「free(bufd);」でメモリ確保の後始末でのメモリ
解放！
「default:return(STI_ARY_5-20);」と指定外ならば、
エラーコード「STI_ARY_5-20」を関数辺値とし返し関数終了
「return(END_STI);」は、正常終了「END_STI」を関数辺値
とし返し関数終了！
（４－１５－８８）関数「void convertLineX(
TypeArray* ps,TypeArray* pd,
BYTE lut[])｛・・・｝」
/************************************************************************/
/***** 水平方向輝度変換 *****/
/***** 輝度の傾きの補正用 *****/
/************************************************************************/
void CopyClear::convertLineX(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列
BYTE lut[] // ＬＵＴ（256×水平幅）
){
BYTE* ptrS; // Ｓ画像ポインタ
BYTE* ptrD; // Ｄ画像ポインタ
BYTE* lutX; // ＬＵＴ：Ｘ座標時のＬＵＴ
int h; // 水平幅
int v; // 垂直幅
int x; // Ｘ座標
int y; // Ｙ座標
h = ( ps->h < pd->h ) ? ps->h : pd->h; // 有効水平幅算出
v = ( ps->v < pd->v ) ? ps->v : pd->v; // 有効垂直幅算出
for( y = 0; y < v; y++ ){ // Ｙ方向繰り返し
ptrS = ps->getPtrByte( 0, y ); // Ｓ画像ポインタセット
ptrD = pd->getPtrByte( 0, y ); // Ｄ画像ポインタセット
lutX = lut; // ＬＵＴ先頭セット
for( x = 0; x < h; x++, lutX += 256 ){ // Ｘ座標を繰り返し
*ptrD++ = lutX[ *ptrS++ ]; // ＬＵＴ変換
} //
} //
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「private:属性」ですのでライブラリの
外から使用不能です！
（Ａ）関数「convertLineX();」の【関数名】
「convert」は、英単語「Convert」として変換するの意味で
す！
「Line」は、カタカナ語ライン詰り線≒水平か垂直方向の
１行／１列を意味し、「LineX」でＸ座標方向＝水平方向に
１行を意味します！
★備考★Ｓ（元）画像が１バイト単位でのＬＵＴ変換
関数ですが、通常のＬＵＴ変換は全ての画素に変換を施すが
ココでは、画素の位置毎に専用のＬＵＴで変換します！
目的として、撮影条件が斜めに成るとかで画素の位置に依っ
て補正を掛ける必要が有る場合のＬＵＴ変換処理です！
（Ｂ）関数「void convertLineX();」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「convertLineX()」の【仮引数】
void CopyClear::convertLineX(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列
BYTE lut[] // ＬＵＴ（256×水平幅）
){「TypeArray* ps,」は、Ｓ（元）画像
「TypeArray* pd,」は、Ｄ（結果）画像
「BYTE lut[]」は、ＬＵＴルックアップテーブル★備考★
サイズは、１バイト画素ＬＵＴ変換用の２５６で無く
２５６×水平幅分のサイズが必要です！
（Ｄ）関数「convertLineX()」の【アルゴリズム】
){
BYTE* ptrS; // Ｓ画像ポインタ
BYTE* ptrD; // Ｄ画像ポインタ
BYTE* lutX; // ＬＵＴ：Ｘ座標時のＬＵＴ
int h; // 水平幅
int v; // 垂直幅
int x; // Ｘ座標
int y; // Ｙ座標
h = ( ps->h < pd->h ) ? ps->h : pd->h; // 有効水平幅算出
v = ( ps->v < pd->v ) ? ps->v : pd->v; // 有効垂直幅算出
for( y = 0; y < v; y++ ){ // Ｙ方向繰り返し
ptrS = ps->getPtrByte( 0, y ); // Ｓ画像ポインタセット
ptrD = pd->getPtrByte( 0, y ); // Ｄ画像ポインタセット
lutX = lut; // ＬＵＴ先頭セット
for( x = 0; x < h; x++, lutX += 256 ){ // Ｘ座標を繰り返し
*ptrD++ = lutX[ *ptrS++ ]; // ＬＵＴ変換
} //
} //
}（Ｄ－１）ローカル変数
){
BYTE* ptrS; // Ｓ画像ポインタ
BYTE* ptrD; // Ｄ画像ポインタ
BYTE* lutX; // ＬＵＴ：Ｘ座標時のＬＵＴ
int h; // 水平幅
int v; // 垂直幅
int x; // Ｘ座標
int y; // Ｙ座標「BYTE* ptrS;」は、Ｓ（元）画像画素ポインタ
「BYTE* ptrD;」は、Ｄ（結果）画像画素ポインタ
「BYTE* lutX;」は、特定Ｘ座標位置ＬＵＴへのポインタ
「int h;」は、水平幅
「int v;」は、垂直幅
「int x;」は、Ｘ座標方向ループカウンタ
「int y;」は、Ｙ座標方向ループカウンタ
（Ｄ―２）アルゴリズムコード
h = ( ps->h < pd->h ) ? ps->h : pd->h; // 有効水平幅算出
v = ( ps->v < pd->v ) ? ps->v : pd->v; // 有効垂直幅算出
for( y = 0; y < v; y++ ){ // Ｙ方向繰り返し
ptrS = ps->getPtrByte( 0, y ); // Ｓ画像ポインタセット
ptrD = pd->getPtrByte( 0, y ); // Ｄ画像ポインタセット
lutX = lut; // ＬＵＴ先頭セット
for( x = 0; x < h; x++, lutX += 256 ){ // Ｘ座標を繰り返し
*ptrD++ = lutX[ *ptrS++ ]; // ＬＵＴ変換
} //
} //
}「h=(ps->h<pd->h)?ps->h:pd->h;
v=(ps->v<pd->v)?ps->v:pd->v;」は、有効（最小）水平垂直
幅を算出！
「for(y=0;y<v;y++){・・外側ループ本体・・}」は、
外内と二重ループの外側ｆｏｒ構文「for(y=0;y<v;y++)」と
教科書的な記述で分かり易く★備考★外側なので高速化の
意味が少ないのと内側ループ用のｆｏｒ構文が教科書的な
アップカウンタの方が都合が良いので同じにした方が分かり
易いと判断して採用！では、外側ループ本体
「ptrS=ps->getPtrByte(0,y);ptrD=pd->getPtrByte(0,y);」
は、水平方向処理用のＳＤ両者の処理ポインタをセット！
「lutX=lut;」は、特定Ｘ座標位置ＬＵＴへのポインタを
先頭（Ｘ座標＝０）にセット！
「for(x=0;x<h;x++,lutX+=256){*ptrD++=lutX[*ptrS++];}」
は、内側ループ用のｆｏｒ構文が教科書的な
「x=0;x<h;x++,」Ｘ座標をアップカウンタで繰り返し、
「lutX+=256」と内側ループ本体が終わるたびに変換用
ＬＵＴを次のＸ座標様に移動します！どして内側ループ本体
「*ptrD++=lutX[*ptrS++];」でＬＵＴ変換します！
（４－１５－８９）関数「void convertLineY(
TypeArray* ps,TypeArray* pd,
BYTE lut[])｛・・・｝」
/************************************************************************/
/***** 垂直方向輝度変換 *****/
/***** 輝度の傾きの補正用 *****/
/************************************************************************/
void CopyClear::convertLineY(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列
BYTE lut[] // ＬＵＴ（256×垂直幅）
){
BYTE* ptrS; // Ｓ画像ポインタ
BYTE* ptrD; // Ｄ画像ポインタ
BYTE* lutY; // ＬＵＴ：Ｙ座標時のＬＵＴ
int h; // 水平幅
int v; // 垂直幅
int y; // Ｙ座標
h = ( ps->h < pd->h ) ? ps->h : pd->h; // 有効水平幅算出
v = ( ps->v < pd->v ) ? ps->v : pd->v; // 有効垂直幅算出
lutY = lut; // ＬＵＴ先頭セット
for( y = 0; y < v; y++, lutY += 256 ){ // Ｙ方向繰り返し
ptrS = ps->getPtrByte( 0, y ); // Ｓ画像ポインタセット
ptrD = pd->getPtrByte( 0, y ); // Ｄ画像ポインタセット
convert_b_b_x( ptrS, ptrD, lutY, h ); // 水平方向にＬＵＴ変換
} //
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「private:属性」ですのでライブラリの
外から使用不能です！
（Ａ）関数「convertLineY();」の【関数名】
「convert」は、英単語「Convert」として変換するの意味で
す！
「Line」は、カタカナ語ライン詰り線≒水平か垂直方向の
１行／１列を意味し、「LineY」でＹ座標方向＝垂直方向に
１列を意味します！
★備考★Ｓ（元）画像が１バイト単位でのＬＵＴ変換
関数ですが、通常のＬＵＴ変換は全ての画素に変換を施すが
ココでは、画素の位置毎に専用のＬＵＴで変換します！
目的として、撮影条件が斜めに成るとかで画素の位置に依っ
て補正を掛ける必要が有る場合のＬＵＴ変換処理です！
（Ｂ）関数「void convertLineY();」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「convertLineY()」の【仮引数】
void CopyClear::convertLineY(
TypeArray *ps, // Ｓ配列（画像）
TypeArray *pd, // Ｄ配列
BYTE lut[] // ＬＵＴ（256×垂直幅）
){「TypeArray* ps,」は、Ｓ（元）画像
「TypeArray* pd,」は、Ｄ（結果）画像
「BYTE lut[]」は、ＬＵＴルックアップテーブル★備考★
サイズは、１バイト画素ＬＵＴ変換用の２５６で無く
２５６×垂直幅分のサイズが必要です！
（Ｄ）関数「convertLineY()」の【アルゴリズム】
){
BYTE* ptrS; // Ｓ画像ポインタ
BYTE* ptrD; // Ｄ画像ポインタ
BYTE* lutY; // ＬＵＴ：Ｙ座標時のＬＵＴ
int h; // 水平幅
int v; // 垂直幅
int y; // Ｙ座標
h = ( ps->h < pd->h ) ? ps->h : pd->h; // 有効水平幅算出
v = ( ps->v < pd->v ) ? ps->v : pd->v; // 有効垂直幅算出
lutY = lut; // ＬＵＴ先頭セット
for( y = 0; y < v; y++, lutY += 256 ){ // Ｙ方向繰り返し
ptrS = ps->getPtrByte( 0, y ); // Ｓ画像ポインタセット
ptrD = pd->getPtrByte( 0, y ); // Ｄ画像ポインタセット
convert_b_b_x( ptrS, ptrD, lutY, h ); // 水平方向にＬＵＴ変換
} //
}（Ｄ－１）ローカル変数
){
BYTE* ptrS; // Ｓ画像ポインタ
BYTE* ptrD; // Ｄ画像ポインタ
BYTE* lutY; // ＬＵＴ：Ｙ座標時のＬＵＴ
int h; // 水平幅
int v; // 垂直幅
int y; // Ｙ座標「BYTE* ptrS;」は、Ｓ（元）画像画素ポインタ
「BYTE* ptrD;」は、Ｄ（結果）画像画素ポインタ
「BYTE* lutY;」は、特定Ｙ座標位置ＬＵＴへのポインタ
「int h;」は、水平幅
「int v;」は、垂直幅
「int y;」は、Ｙ座標方向ループカウンタ
（Ｄ―２）アルゴリズムコード
h = ( ps->h < pd->h ) ? ps->h : pd->h; // 有効水平幅算出
v = ( ps->v < pd->v ) ? ps->v : pd->v; // 有効垂直幅算出
lutY = lut; // ＬＵＴ先頭セット
for( y = 0; y < v; y++, lutY += 256 ){ // Ｙ方向繰り返し
ptrS = ps->getPtrByte( 0, y ); // Ｓ画像ポインタセット
ptrD = pd->getPtrByte( 0, y ); // Ｄ画像ポインタセット
convert_b_b_x( ptrS, ptrD, lutY, h ); // 水平方向にＬＵＴ変換
} //
}「h=(ps->h<pd->h)?ps->h:pd->h;
v=(ps->v<pd->v)?ps->v:pd->v;」は、有効（最小）水平垂直
幅を算出！
「lutY=lut;」は、特定Ｙ座標位置ＬＵＴへのポインタを
先頭（Ｙ座標＝０）にセット！
「for(y=0;y<v;y++,lutY+=256){・・ループ本体・・}」は、
ループのｆｏｒ構文「for(y=0;y<v;y++)」と
教科書的な記述で分かり易く★備考★外側なので高速化の
意味が少ないの教科書的なアップカウンタの方が都合が良い
ので採用！では、
「lutY+=256」とループ本体が終わるたびに変換用ＬＵＴを
次のＹ座標様に移動します！
「ptrS=ps->getPtrByte(0,y);ptrD=pd->getPtrByte(0,y);」
は、垂直方向処理用のＳＤ両者の処理ポインタをセット！
「convert_b_b_x(ptrS,ptrD,lutY,h);」で
サブルーチン関数「convert_b_b_x()」ＬＵＴ変換処理
（４－１５－９０）関数「void makeCvtLineLUTSingle(
BYTE lut[],int maxData)｛・・・｝」
/********************************************************************************/
/***** 水平／垂直方向輝度変換用ＬＵＴ作成 *****/
/***** ＬＵＴ［0..255］一組み用 *****/
/***** ☆注☆maxData=1..255ならそのまま変換。ただし輝度は低くなる。 *****/
/***** ☆注☆maxData=1..65535なら高輝度変換可能。ただしサチル。 *****/
/********************************************************************************/
void CopyClear::makeCvtLineLUTSingle(
BYTE lut[], // ＬＵＴポインタ
int maxData // 最大値 1..65535
){
int i; // カウンタ
double cvt; // 変換データ
int d; // 変換後データ
cvt = maxData / 255.0; // 変換データ作成
for( i = 0; i < 256; i++ ){ // 0..255繰り返し
d = (int)( (double)i * cvt + 0.5 ); // 変換後データ作成
if( d > 255 ){ // 255Over時
d = 255; // 255に補正
} //
lut[i] = d; // ＬＵＴ作成
} //
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「private:属性」ですのでライブラリの
外から使用不能です！
（Ａ）関数「makeCvtLineLUTSingle();」の【関数名】
「make」は、作成するで、
「Cvt」は、英単語「Convert」の省略として変換するの
意味です！
「Line」は、カタカナ語ライン詰り線≒水平か垂直方向の
１行／１列を意味し、「LineLUT」でその変換に使用する
ＬＵＴを意味します！
「Single」で「単一の」とかの意味で変換用ＬＵＴの
水平／垂直何れか片方のＬＵＴを作成する事を命名かな？！
★備考★今と成っては、残念ながら詳細は思い出せないが、
恐らく、アルゴリズムから推測してＬＵＴの１単位分を意味
ではと思う！
（Ｂ）関数「void makeCvtLineLUTSingle();」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「makeCvtLineLUTSingle()」の【仮引数】
void CopyClear::makeCvtLineLUTSingle(
BYTE lut[], // ＬＵＴポインタ
int maxData // 最大値 1..65535
){「BYTE lut[]」は、ＬＵＴルックアップテーブル★備考★
サイズは、１バイト画素ＬＵＴ変換用の２５６で無く
２５６×垂直幅分のサイズが必要です！
「int maxData」は、ＬＵＴ変換する最大輝度値
（Ｄ）関数「makeCvtLineLUTSingle()」の【アルゴリズム】
){
int i; // カウンタ
double cvt; // 変換データ
int d; // 変換後データ
cvt = maxData / 255.0; // 変換データ作成
for( i = 0; i < 256; i++ ){ // 0..255繰り返し
d = (int)( (double)i * cvt + 0.5 ); // 変換後データ作成
if( d > 255 ){ // 255Over時
d = 255; // 255に補正
} //
lut[i] = d; // ＬＵＴ作成
} //
}（Ｄ－１）ローカル変数
){
int i; // カウンタ
double cvt; // 変換データ
int d; // 変換後データ「int i;」は、ループカウンタ
「double cvt;」は、変換データ
「int d;」は、変換後データ
（Ｄ―２）アルゴリズムコード
cvt = maxData / 255.0; // 変換データ作成
for( i = 0; i < 256; i++ ){ // 0..255繰り返し
d = (int)( (double)i * cvt + 0.5 ); // 変換後データ作成
if( d > 255 ){ // 255Over時
d = 255; // 255に補正
} //
lut[i] = d; // ＬＵＴ作成
} //
}「cvt=maxData/255.0;」は、変換用の基礎係数算出
「for(i=0;i<256;i++){・・本体・・}」は、教科書的な
カウントアップ方式のｆｏｒ構文「i=0;i<256;i++」で
「0..255」の範囲で本体を繰り返します！その本体
「d=(int)((double)icvt+0.5);if(d>255){d=255;}
lut[i]=d;」と先ず、「d=(int)((double)i*cvt+0.5);」で
変換用後の値を算出し、ｉｆ構文「if(d>255){d=255;}」で
値が「255詰り１バイト最大値」を越えたら２５５に補正
「lut[i]=d;」とＬＵＴに格納！
（４－１５－９１）関数「int makeCvtLineLUT(BYTE lut[],
BYTE tbl[],int len)｛・・・｝」
/************************************************************************/
/***** 水平／垂直方向輝度変換用ＬＵＴ作成 *****/
/************************************************************************/
int CopyClear::makeCvtLineLUT(
BYTE lut[], // ＬＵＴ（256×水平／垂直幅）
BYTE tbl[], // 割合テーブル「0..255」
int len // 水平／垂直幅
){
BYTE** buf; // LUTへのPtrバッファー
BYTE* lutXY; // ＬＵＴ（256：個別）
int k; // 割合（255に対して）
int i; // カウンタ
buf = (BYTE**)malloc( sizeof(BYTE*) * 256 ); // バッファーメモリ確保
if( buf == 0 ){ // 確保失敗時は
return( STI_MEM ); // 左記を返す
} //
for( i = 0; i < 256; i++ ){ // バッファーに
buf[i] = 0; // 空ptrをセット
} //
for( i = 0; i < len; i++ ){ // 幅分繰り返し
lutXY = &lut[ i * 256 ]; // ＬＵＴ（256：個別）セット
k = tbl[i]; // 割合取り出し
if( buf[k] == 0 ){ // 非登録なら
makeCvtLineLUTSingle( lutXY, k ); // 左記でＬＵＴ作成
buf[k] = lutXY; // この時のLUTを登録
}else{ // 登録済みなら
up_mova( buf[k], lutXY, 256 ); // LUTデータをコピー
} //
} //
free( buf ); // バッファーメモリ解放
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「private:属性」ですのでライブラリの
外から使用不能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「makeCvtLineLUT();」の【関数名】
「make」は、作成するで、
「Cvt」は、英単語「Convert」の省略として変換するの
意味です！
「Line」は、カタカナ語ライン詰り線≒水平か垂直方向の
１行／１列を意味し、「LineLUT」でその変換に使用する
ＬＵＴを意味します！
（Ｂ）関数「int makeCvtLineLUT();」の【返値】
内部で動的にバッファーを確保失敗したらエラーコード
「STI_MEM」を関数辺値とし返し、正常に終了したら
「END_STI」を辺値とし返し関数終了！
（Ｃ）関数「makeCvtLineLUT()」の【仮引数】
int CopyClear::makeCvtLineLUT(
BYTE lut[], // ＬＵＴ（256×水平／垂直幅）
BYTE tbl[], // 割合テーブル「0..255」
int len // 水平／垂直幅
){「BYTE lut[],」は、ＬＵＴ★備考★サイズは、
２５６×「int len」のサイズ
「BYTE tbl[],」は、割合「0..255」格納テーブル
「int len」は、ライン（水平及び垂直）のサイズ（幅）
（Ｄ）関数「makeCvtLineLUT()」の【アルゴリズム】
){
BYTE** buf; // LUTへのPtrバッファー
BYTE* lutXY; // ＬＵＴ（256：個別）
int k; // 割合（255に対して）
int i; // カウンタ
buf = (BYTE**)malloc( sizeof(BYTE*) * 256 ); // バッファーメモリ確保
if( buf == 0 ){ // 確保失敗時は
return( STI_MEM ); // 左記を返す
} //
for( i = 0; i < 256; i++ ){ // バッファーに
buf[i] = 0; // 空ptrをセット
} //
for( i = 0; i < len; i++ ){ // 幅分繰り返し
lutXY = &lut[ i * 256 ]; // ＬＵＴ（256：個別）セット
k = tbl[i]; // 割合取り出し
if( buf[k] == 0 ){ // 非登録なら
makeCvtLineLUTSingle( lutXY, k ); // 左記でＬＵＴ作成
buf[k] = lutXY; // この時のLUTを登録
}else{ // 登録済みなら
up_mova( buf[k], lutXY, 256 ); // LUTデータをコピー
} //
} //
free( buf ); // バッファーメモリ解放
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
BYTE** buf; // LUTへのPtrバッファー
BYTE* lutXY; // ＬＵＴ（256：個別）
int k; // 割合（255に対して）
int i; // カウンタ「BYTE** buf;」は、ＬＵＴへのポインターのバッファー
「BYTE* lutXY;」は、ＬＵＴ≪サイズが２５６≫個別ポイ
ンタ★備考★ＸＹは、殊更にＸ座標／Ｙ座標成分を現わして
いる程度に考えてくださいと余り意味のない名称です！
「int k;」は、割合個別係数
「int i;」は、ループカウンタ
（Ｄ―２）アルゴリズムコード
buf = (BYTE**)malloc( sizeof(BYTE*) * 256 ); // バッファーメモリ確保
if( buf == 0 ){ // 確保失敗時は
return( STI_MEM ); // 左記を返す
} //
for( i = 0; i < 256; i++ ){ // バッファーに
buf[i] = 0; // 空ptrをセット
} //
for( i = 0; i < len; i++ ){ // 幅分繰り返し
lutXY = &lut[ i * 256 ]; // ＬＵＴ（256：個別）セット
k = tbl[i]; // 割合取り出し
if( buf[k] == 0 ){ // 非登録なら
makeCvtLineLUTSingle( lutXY, k ); // 左記でＬＵＴ作成
buf[k] = lutXY; // この時のLUTを登録
}else{ // 登録済みなら
up_mova( buf[k], lutXY, 256 ); // LUTデータをコピー
} //
} //
free( buf ); // バッファーメモリ解放
return( END_STI ); // 正常終了
}「buf=(BYTE**)malloc(sizeof(BYTE*)*256);」は、
「BYTE型」のバッファーを２５６サイズ取得、
「if(buf==0){return(STI_MEM);}」で取得失敗したら、
エラーコード「STI_MEM」を関数辺値とし返し関数終了！
「for(i=0;i<256;i++){buf[i]=0;}」は、上記で取得した
バッファーを空ポインタで初期化！
「for(i=0;i<len;i++){・・本体・・}」は、教科書的な
カウントアップ方式でのｆｏｒ構文「i=0;i<len;i++」で
「0..len-1」までの範囲で繰り返し、本体
「lutXY=&lut[i*256];k=tbl[i];」で個別ＬＵＴへの
ポインタと個別の係数を取り出し、
「if(buf[k]==0){makeCvtLineLUTSingle(lutXY,k);
buf[k]=lutXY;}」とｉｆ条件「buf[k]==0」と「==0」なら
詰り、初期状態の空ポインタなら、「lutXY=&lut[i256];」
と仮引数「BYTE lut[],」から個別の２５６バイトサイズの
ＬＵＴを切り取る様にポインタを「lutXY」にセットした
後で「makeCvtLineLUTSingle(lutXY,k);」とサブルーチン
関数「makeCvtLineLUTSingle()」でＬＵＴを１単位作成
「buf[k]=lutXY;」と取得したバッファーへポインタセット
「else{up_mova(buf[k],lutXY,256);}」は、既にポインタ
がセットしてあれば、サブルーチン関数「up_mova()」で
内容をコピー
「free(buf);」は、後始末とし動的確保したバッファーを
解放します！
「return(END_STI);」は、正常終了を関数辺値とし返し、
関数終了！
（４－１５－９２）関数「int makeCvtLineLUT(
BYTE lut[],UWORD tbl[],int len)｛・・・｝」
/************************************************************************/
/***** 水平／垂直方向輝度変換用ＬＵＴ作成 *****/
/***** ☆注☆「割合」を0..1023と255を超える設定が可能で *****/
/***** ☆注☆画像を高輝度に変換可能、ただし、255以上はサチル。 *****/
/************************************************************************/
int CopyClear::makeCvtLineLUT(
BYTE lut[], // ＬＵＴ（256×水平／垂直幅）
UWORD tbl[], // 割合テーブル「0..1023」
int len // 水平／垂直幅
){
BYTE** buf; // LUTへのPtrバッファー
BYTE* lutXY; // ＬＵＴ（256：個別）
int k; // 割合（255に対して）
int i; // カウンタ
buf = (BYTE**)malloc( sizeof(BYTE*) * 1024 ); // バッファーメモリ確保
if( buf == 0 ){ // 確保失敗時は
return( STI_MEM ); // 左記を返す
} //
for( i = 0; i < 1024; i++ ){ // バッファーに
buf[i] = 0; // 空ptrをセット
} //
for( i = 0; i < len; i++ ){ // 幅分繰り返し
lutXY = &lut[ i * 256 ]; // ＬＵＴ（256：個別）セット
k = tbl[i]; // 割合取り出し
if( k > 1023 ){ // 1023 Overなら
k = 1023; // 1023に補正
} //
if( buf[k] == 0 ){ // 非登録なら
makeCvtLineLUTSingle( lutXY, k ); // 左記でＬＵＴ作成
buf[k] = lutXY; // この時のLUTを登録
}else{ // 登録済みなら
up_mova( buf[k], lutXY, 256 ); // LUTデータをコピー
} //
} //
free( buf ); // バッファーメモリ解放
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear030.cpp」に存在！
★注意★この関数は「private:属性」ですのでライブラリの
外から使用不能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「makeCvtLineLUT();」の【関数名】
「make」は、作成するで、
「Cvt」は、英単語「Convert」の省略として変換するの
意味です！
「Line」は、カタカナ語ライン詰り線≒水平か垂直方向の
１行／１列を意味し、「LineLUT」でその変換に使用する
ＬＵＴを意味します！
（Ｂ）関数「int makeCvtLineLUT();」の【返値】
内部で動的にバッファーを確保失敗したらエラーコード
「STI_MEM」を関数辺値とし返し、正常に終了したら
「END_STI」を辺値とし返し関数終了！
（Ｃ）関数「makeCvtLineLUT()」の【仮引数】
int CopyClear::makeCvtLineLUT(
BYTE lut[], // ＬＵＴ（256×水平／垂直幅）
UWORD tbl[], // 割合テーブル「0..1023」
int len // 水平／垂直幅
){「BYTE lut[],」は、ＬＵＴ★備考★サイズは、
２５６×「int len」のサイズ
「UWORD tbl[],」は、割合「0..255」格納テーブル
「int len」は、ライン（水平及び垂直）のサイズ（幅）
（Ｄ）関数「makeCvtLineLUT()」の【アルゴリズム】
){
BYTE** buf; // LUTへのPtrバッファー
BYTE* lutXY; // ＬＵＴ（256：個別）
int k; // 割合（255に対して）
int i; // カウンタ
buf = (BYTE**)malloc( sizeof(BYTE*) * 1024 ); // バッファーメモリ確保
if( buf == 0 ){ // 確保失敗時は
return( STI_MEM ); // 左記を返す
} //
for( i = 0; i < 1024; i++ ){ // バッファーに
buf[i] = 0; // 空ptrをセット
} //
for( i = 0; i < len; i++ ){ // 幅分繰り返し
lutXY = &lut[ i * 256 ]; // ＬＵＴ（256：個別）セット
k = tbl[i]; // 割合取り出し
if( k > 1023 ){ // 1023 Overなら
k = 1023; // 1023に補正
} //
if( buf[k] == 0 ){ // 非登録なら
makeCvtLineLUTSingle( lutXY, k ); // 左記でＬＵＴ作成
buf[k] = lutXY; // この時のLUTを登録
}else{ // 登録済みなら
up_mova( buf[k], lutXY, 256 ); // LUTデータをコピー
} //
} //
free( buf ); // バッファーメモリ解放
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
BYTE** buf; // LUTへのPtrバッファー
BYTE* lutXY; // ＬＵＴ（256：個別）
int k; // 割合（255に対して）
int i; // カウンタ「BYTE** buf;」は、ＬＵＴへのポインターのバッファー
「BYTE* lutXY;」は、ＬＵＴ≪サイズが２５６≫個別ポイ
ンタ★備考★ＸＹは、殊更にＸ座標／Ｙ座標成分を現わして
いる程度に考えてくださいと余り意味のない名称です！
「int k;」は、割合個別係数
「int i;」は、ループカウンタ
（Ｄ―２）アルゴリズムコード
buf = (BYTE**)malloc( sizeof(BYTE*) * 1024 ); // バッファーメモリ確保
if( buf == 0 ){ // 確保失敗時は
return( STI_MEM ); // 左記を返す
} //
for( i = 0; i < 1024; i++ ){ // バッファーに
buf[i] = 0; // 空ptrをセット
} //
for( i = 0; i < len; i++ ){ // 幅分繰り返し
lutXY = &lut[ i * 256 ]; // ＬＵＴ（256：個別）セット
k = tbl[i]; // 割合取り出し
if( k > 1023 ){ // 1023 Overなら
k = 1023; // 1023に補正
} //
if( buf[k] == 0 ){ // 非登録なら
makeCvtLineLUTSingle( lutXY, k ); // 左記でＬＵＴ作成
buf[k] = lutXY; // この時のLUTを登録
}else{ // 登録済みなら
up_mova( buf[k], lutXY, 256 ); // LUTデータをコピー
} //
} //
free( buf ); // バッファーメモリ解放
return( END_STI ); // 正常終了
}「buf=(BYTE**)malloc(sizeof(BYTE*)*1024);」は、
「BYTE型」のバッファーを１０２４サイズ取得、
「if(buf==0){return(STI_MEM);}」で取得失敗したら、
エラーコード「STI_MEM」を関数辺値とし返し関数終了！
「for(i=0;i<1024;i++){buf[i]=0;}」は、上記で取得した
バッファーを空ポインタで初期化！
「for(i=0;i<len;i++){・・本体・・}」は、教科書的な
カウントアップ方式でのｆｏｒ構文「i=0;i<len;i++」で
「0..len-1」までの範囲で繰り返し、本体
「lutXY=&lut[i*256];k=tbl[i];
if(k>1023){k=1023;}」で個別ＬＵＴへのポインタと個別の
係数を取り出し、条件「k>1023」なら「k=1023;」と補正し
「if(buf[k]==0){makeCvtLineLUTSingle(lutXY,k);
buf[k]=lutXY;}」とｉｆ条件「buf[k]==0」と「==0」なら
詰り、初期状態の空ポインタなら、「lutXY=&lut[i256];」
と仮引数「BYTE lut[],」から個別の２５６バイトサイズの
ＬＵＴを切り取る様にポインタを「lutXY」にセットした
後で「makeCvtLineLUTSingle(lutXY,k);」とサブルーチン
関数「makeCvtLineLUTSingle()」でＬＵＴを１単位作成
「buf[k]=lutXY;」と取得したバッファーへポインタセット
「else{up_mova(buf[k],lutXY,256);}」は、既にポインタ
がセットしてあれば、サブルーチン関数「up_mova()」で
内容をコピー
「free(buf);」は、後始末とし動的確保したバッファーを
解放します！
「return(END_STI);」は、正常終了を関数辺値とし返し、
関数終了！
★備考★１０２４＝１０ビットの振り幅を用意して居るのは
カメラの１画素の値が「0..1023」と有るカメラ用の関数で
す！
ココまでで区切り≪「private:属性」の関数の並びが、
「makeCvtLineLUT()」関数までとＬＵＴ作成の基本部（
整数型から整数型及び浮動小数点型）が終了したので
次から「BinarizationMyselfBase()」と毛色の変わった関数
の説明になるので≫が良いので終わります？！
継続追加は有りません！★備考★
勿論、記載ミスは直して行きますが！
引き続き、
新規解説『解説クラスＣｏｐｙＣｌｅａｒ（３４）』を
御贔屓下さい！