解説クラスＣｏｐｙＣｌｅａｒ（１４）
解説クラスＣｏｐｙＣｌｅａｒ（１４）
２０２５年１月１４初稿
（４－１４－２８）関数「void Make3Lut(BYTE lut[],int x1,int y1,int x2,int y2){・・・｝」の説明
/************************************************************************/
/***** ＬＵＴデータの作成：任意直線パターン *****/
/************************************************************************/
void CopyClear::Make3Lut(
BYTE lut[], // 作成するＬＵＴ
int x1, // Pattern書込始点Ix
int y1, // Pattern書込始点データ
int x2, // Pattern書込終点Ix
int y2 // Pattern書込終点データ
){
BYTE *p; // 始点ポインタ
int k; // 直線の傾き係数
int x; // 書き込むIx値
if( x1 == x2 ){ // 始終点が同じなら
lut[ x1 ] = y2; // 終点の値を書き込み
return; // 抜ける
} //
k = ( ( y2 - y1 ) << 23 ) / ( x2 - x1 ); // 傾きを求める
p = &lut[ x1 ]; // 始点作成
for( x = 0, x2 -= x1; x <= x2; x++ ){ // インデックスの範囲で
*p++ = y1 + ((( k * x >> 22) + 1) >> 1);// データを算出し書込む
} //
}☆備考☆この関数はファイル「CopyClear040.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「Make3Lut()」の【関数名】説明
「Make」は、作成するで
「Lut」は、勿論、ＬＵＴ変換用のＬＵＴです！
ココでは、「Make○○Lut」と枝番号○○で機能分けした内の
一つのＬＵＴパターン作成の意味です！
ここの○○＝３は、任意直線パターン作成です！
このイメージです！
（Ｂ）関数「void Make3Lut()」の【返値】説明
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「Make3Lut()」の【仮引数】説明
void CopyClear::Make3Lut(
BYTE lut[], // 作成するＬＵＴ
int x1, // Pattern書込始点Ix
int y1, // Pattern書込始点データ
int x2, // Pattern書込終点Ix
int y2 // Pattern書込終点データ
){「BYTE lut[],」はＬＵＴを一次元配列として使用！
「int x1,」は、始点Ｘ座標です
「int y1,」は、始点Ｙ座標です
「int x2,」は、終点Ｘ座標です
「int y2」は、終点Ｙ座標です
★注意★ＬＵＴ配列の添え字方向をＸ座標方向とし、
ＬＵＴ配列に格納する値をＹ座標方向として幾何学的に
図示したグラフと考えてＸＹ座標との表現にしています！
（Ｄ）関数「Make3Lut()」の【アルゴリズム】説明
){
BYTE *p; // 始点ポインタ
int k; // 直線の傾き係数
int x; // 書き込むIx値
if( x1 == x2 ){ // 始終点が同じなら
lut[ x1 ] = y2; // 終点の値を書き込み
return; // 抜ける
} //
k = ( ( y2 - y1 ) << 23 ) / ( x2 - x1 ); // 傾きを求める
p = &lut[ x1 ]; // 始点作成
for( x = 0, x2 -= x1; x <= x2; x++ ){ // インデックスの範囲で
*p++ = y1 + ((( k * x >> 22) + 1) >> 1);// データを算出し書込む
} //
}（Ｄ－１）ローカル変数
){
BYTE *p; // 始点ポインタ
int k; // 直線の傾き係数
int x; // 書き込むIx値「BYTE* p;」は、ＬＵＴ格納操作用のポインタ
「int k;」は、直線線分の傾き係数
「int x;」は、ＬＵＴ配列の添え字
（Ｄ－２）アルゴリズムコード
if( x1 == x2 ){ // 始終点が同じなら
lut[ x1 ] = y2; // 終点の値を書き込み
return; // 抜ける
} //
k = ( ( y2 - y1 ) << 23 ) / ( x2 - x1 ); // 傾きを求める
p = &lut[ x1 ]; // 始点作成
for( x = 0, x2 -= x1; x <= x2; x++ ){ // インデックスの範囲で
*p++ = y1 + ((( k * x >> 22) + 1) >> 1);// データを算出し書込む
} //
}「if(x1==x2){lut[x1]=y2;return;}」は、Ｘ座標の始終点
が同じということでそのＬＵＴ配列の添え字場所にＹ座標
終点値を格納し関数終了
「k=((y2-y1)<<23)/(x2-x1);」は、傾き係数の算出です！
★注意★「<<23」とは、元のＬＵＴへの格納値がＹ座標値で
８ビット以内（０～２５５）と見なしているのでシフト演算
［<<23］と乗算「×8388608」と同じ演算を古いＣＰＵでも
シフト演算なので高速に動作出来る事で３２ビット整数を
目いっぱい下駄履きに使用した演算で「/(x2-x1)」と
Ｘ座標方向の変位を使用して除算しても小数点以下の値が
十分と考えた！
「p=&lut[x1];」は、ＬＵＴ配列書き込みポインタセット
「for(x=0,x2-=x1;x<=x2;x++){
*p++=y1+(((k*x>>22)+1)>>1);}」は、ｆｏｒループ構文で
「for(x=0,x2-=x1;x<=x2;x++){・・中身・・}」と
作図上のＸ座標を０にし、終点座標を「x2-=x1」と０
から原点に補正し、条件「x<=x2;」と終点まで「x++」と
増加、そして中身「*p++=y1+(((k*x>>22)+1)>>1);」で
作図上Ｙ座標成分値「y1+(((k*x>>22)+1)>>1)」とＹ座標
始点「y1」に増分「((k*x>>22)+1)>>1」と演算し増分を
８ビット内に下駄を外す為に「>>22」と「>>1」と２段で
下駄を外しています！★注意★「+1)>>1」の記載は、
「「+1)」が、一番奥の最小桁数値の四捨五入処理だと
理解して下さい！※備考※勿論、Ｃ言語ならではのシフト
演算を使用した高速化処理例で下駄履きで小数点以下の数値
も扱っても結果整数値に四捨五入で丸めています！
（４－１４－２９）関数「void Make4Lut(BYTE lut[],int x1,int y1,int x2,int y2){・・・｝」の説明
/************************************************************************/
/***** ＬＵＴデータの作成：任意曲線パターン *****/
/***** ※注意：現在はMake3Lut()と同じ処理※ *****/
/************************************************************************/
void CopyClear::Make4Lut(
BYTE lut[], // 作成するＬＵＴ
int x1, // Pattern書込始点Ix
int y1, // Pattern書込始点データ
int x2, // Pattern書込終点Ix
int y2 // Pattern書込終点データ
){
BYTE *p; // 始点ポインタ
int k; // 直線の傾き係数
int x; // 書き込むIx値
if( x1 == x2 ){ // 始終点が同じなら
lut[ x1 ] = y2; // 終点の値を書き込み
return; // 抜ける
} //
k = ( ( y2 - y1 ) << 23 ) / ( x2 - x1 ); // 傾きを求める
p = &lut[ x1 ]; // 始点作成
for( x = 0, x2 -= x1; x <= x2; x++ ){ // インデックスの範囲で
*p++ = y1 + ((( k * x >> 22) + 1) >> 1);// データを算出し書込む
} //
}☆備考☆この関数はファイル「CopyClear040.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「Make4Lut()」の【関数名】説明
「Make」は、作成するで
「Lut」は、勿論、ＬＵＴ変換用のＬＵＴです！
ココでは、「Make○○Lut」と枝番号○○で機能分けした内の
一つのＬＵＴパターン作成の意味です！
ここの○○＝４は、任意曲線パターン作成です！
このイメージです！
（Ｂ）関数「void Make4Lut()」の【返値】説明
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「Make4Lut()」の【仮引数】説明
void CopyClear::Make4Lut(
BYTE lut[], // 作成するＬＵＴ
int x1, // Pattern書込始点Ix
int y1, // Pattern書込始点データ
int x2, // Pattern書込終点Ix
int y2 // Pattern書込終点データ
){「BYTE lut[],」はＬＵＴを一次元配列として使用！
「int x1,」は、始点Ｘ座標です
「int y1,」は、始点Ｙ座標です
「int x2,」は、終点Ｘ座標です
「int y2」は、終点Ｙ座標です
★注意★ＬＵＴ配列の添え字方向をＸ座標方向とし、
ＬＵＴ配列に格納する値をＹ座標方向として幾何学的に
図示したグラフと考えてＸＹ座標との表現にしています！
（Ｄ）関数「Make4Lut()」の【アルゴリズム】説明
){
BYTE *p; // 始点ポインタ
int k; // 直線の傾き係数
int x; // 書き込むIx値
if( x1 == x2 ){ // 始終点が同じなら
lut[ x1 ] = y2; // 終点の値を書き込み
return; // 抜ける
} //
k = ( ( y2 - y1 ) << 23 ) / ( x2 - x1 ); // 傾きを求める
p = &lut[ x1 ]; // 始点作成
for( x = 0, x2 -= x1; x <= x2; x++ ){ // インデックスの範囲で
*p++ = y1 + ((( k * x >> 22) + 1) >> 1);// データを算出し書込む
} //
}（Ｄ－１）ローカル変数
){
BYTE *p; // 始点ポインタ
int k; // 直線の傾き係数
int x; // 書き込むIx値「BYTE* p;」は、ＬＵＴ格納操作用のポインタ
「int k;」は、直線線分の傾き係数
「int x;」は、ＬＵＴ配列の添え字
（Ｄ－２）アルゴリズムコード
if( x1 == x2 ){ // 始終点が同じなら
lut[ x1 ] = y2; // 終点の値を書き込み
return; // 抜ける
} //
k = ( ( y2 - y1 ) << 23 ) / ( x2 - x1 ); // 傾きを求める
p = &lut[ x1 ]; // 始点作成
for( x = 0, x2 -= x1; x <= x2; x++ ){ // インデックスの範囲で
*p++ = y1 + ((( k * x >> 22) + 1) >> 1);// データを算出し書込む
} //
}「if(x1==x2){lut[x1]=y2;return;}」は、Ｘ座標の始終点
が同じということでそのＬＵＴ配列の添え字場所にＹ座標
終点値を格納し関数終了
「k=((y2-y1)<<23)/(x2-x1);」は、傾き係数の算出です！
★注意★「<<23」とは、元のＬＵＴへの格納値がＹ座標値で
８ビット以内（０～２５５）と見なしているのでシフト演算
［<<23］と乗算「8388608」と同じ演算を古いＣＰＵでも
シフト演算なので高速に動作出来る事で３２ビット整数を
目いっぱい下駄履きに使用した演算で「/(x2-x1)」と
Ｘ座標方向の変位を使用して除算しても小数点以下の値が
十分と考えた！
「*p=&lut[x1];」は、ＬＵＴ配列書き込みポインタセット
「for(x=0,x2-=x1;x<=x2;x++){
*p++=y1+(((k*x>>22)+1)>>1);}」は、ｆｏｒループ構文で
「for(x=0,x2-=x1;x<=x2;x++){・・中身・・}」と
作図上のＸ座標を０にし、終点座標を「x2-=x1」と０
から原点に補正し、条件「x<=x2;」と終点まで「x++」と
増加、そして中身「*p++=y1+(((k*x>>22)+1)>>1);」で
作図上Ｙ座標成分値「y1+(((k*x>>22)+1)>>1)」とＹ座標
始点「y1」に増分「((k*x>>22)+1)>>1」と演算し増分を
８ビット内に下駄を外す為に「>>22」と「>>1」と２段で
下駄を外しています！★注意★「+1)>>1」の記載は、
「「+1)」が、一番奥の最小桁数値の四捨五入処理だと
理解して下さい！※備考※勿論、Ｃ言語ならではのシフト
演算を使用した高速化処理例で下駄履きで小数点以下の数値
も扱っても結果整数値に四捨五入で丸めています！
（Ｅ）関数「Make4Lut()」の【備考】
関数コードの記載の中のコメント
「※注意：現在はMake3Lut()と同じ処理※」と有る様に
仮引数「int x1,int y1,int x2,int y2」とＸＹ座標が
（x1,y1）と（x2,y2）と２点間を結ぶ曲線を作成する心算
だったが、勿論、２点間では直線にしか成らないので
「Make3Lut()と同じ」に成るのだ？！当初、Ｃ＋＋言語の
多重定義（オーバーロード）関数追加、詰り
「void Make4Lut(BYTE lut[],int x1,int y1,
int x2,int y2,int x3,int y3)」とか「void Make4Lut(
BYTE lut[],int x1,int y1,int x2,int y2,int x3,
int y3,int x4,int y4)」及び「void Make4Lut(
BYTE lut[],int x1,int y1,int x2,int y2,int x3,
int y3,int x4,int y4),int x5,int y5)」と座標の点数を
増やし、３点以上は、其れなりに曲線に成る事を考えていた
が、他のライブラリ関数を整備する方を優先し、コレは後回
しにし、ソノママです！※備考※特に必要とは考えて無かっ
たと言い訳！
（４－１４－３０）関数「int Make5Lut(BYTE lut[],int k,int sw){・・・｝」の説明
/************************************************************************/
/***** ＬＵＴデータの作成：Γ／ｌｏｇパターン *****/
/***** 返し値：エラーチェックの値（END_STI,STI_FLG） *****/
/***** 注意① Γ／ｌｏｇ選択子省略時（負値） *****/
/***** → ０（Γ補正：中央強調） *****/
/***** 注意② 反転ｓｗ選択子省略時（負値）→０（無反転） *****/
/************************************************************************/
int CopyClear::Make5Lut(
BYTE lut[], // 作成するＬＵＴ
int k, // Γ／ｌｏｇ選択子
int sw // 反転ｓｗ(0:無/1:反転)
){
/********************************************************************/
/********** Γ table for ＬＵＴ *********/
/********** y = 256 * ( x / 256 ) ** 1.2 *********/
/********************************************************************/
static const BYTE pow12[] = {
0, 0, 1, 1, 2, 2, 3, 3, 4, 5,
5, 6, 7, 7, 8, 9, 9, 10, 11, 11,
12, 13, 13, 14, 15, 16, 16, 17, 18, 19,
20, 20, 21, 22, 23, 24, 24, 25, 26, 27,
28, 28, 29, 30, 31, 32, 33, 33, 34, 35,
36, 37, 38, 39, 40, 40, 41, 42, 43, 44,
45, 46, 47, 48, 49, 49, 50, 51, 52, 53,
54, 55, 56, 57, 58, 59, 60, 61, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
124, 125, 126, 127, 128, 129, 130, 132, 133, 134,
135, 136, 137, 138, 139, 140, 141, 142, 143, 145,
146, 147, 148, 149, 150, 151, 152, 153, 154, 156,
157, 158, 159, 160, 161, 162, 163, 164, 166, 167,
168, 169, 170, 171, 172, 173, 174, 176, 177, 178,
179, 180, 181, 182, 184, 185, 186, 187, 188, 189,
190, 192, 193, 194, 195, 196, 197, 198, 200, 201,
202, 203, 204, 205, 206, 208, 209, 210, 211, 212,
213, 215, 216, 217, 218, 219, 220, 222, 223, 224,
225, 226, 227, 229, 230, 231, 232, 233, 235, 236,
237, 238, 239, 240, 242, 243, 244, 245, 246, 248,
249, 250, 251, 252, 254, 255,
};
/********************************************************************/
/********** Γ table for ＬＵＴ *********/
/********** y = 256 * ( x / 256 ) ** 0.8 *********/
/********************************************************************/
static const BYTE pow08[0x100] = {
0, 3, 5, 7, 9, 11, 13, 14, 16, 18,
19, 21, 22, 24, 25, 26, 28, 29, 31, 32,
33, 35, 36, 37, 39, 40, 41, 42, 44, 45,
46, 47, 49, 50, 51, 52, 53, 54, 56, 57,
58, 59, 60, 61, 63, 64, 65, 66, 67, 68,
69, 70, 72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, 86, 87, 88, 89, 90,
91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
121, 122, 123, 124, 125, 125, 126, 127, 128, 129,
130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
140, 141, 141, 142, 143, 144, 145, 146, 147, 148,
149, 150, 151, 152, 153, 153, 154, 155, 156, 157,
158, 159, 160, 161, 162, 162, 163, 164, 165, 166,
167, 168, 169, 170, 170, 171, 172, 173, 174, 175,
176, 177, 178, 178, 179, 180, 181, 182, 183, 184,
185, 185, 186, 187, 188, 189, 190, 191, 191, 192,
193, 194, 195, 196, 197, 197, 198, 199, 200, 201,
202, 203, 203, 204, 205, 206, 207, 208, 208, 209,
210, 211, 212, 213, 213, 214, 215, 216, 217, 218,
218, 219, 220, 221, 222, 223, 223, 224, 225, 226,
227, 228, 228, 229, 230, 231, 232, 233, 233, 234,
235, 236, 237, 237, 238, 239, 240, 241, 241, 242,
243, 244, 245, 246, 246, 247, 248, 249, 250, 250,
251, 252, 253, 254, 254, 255,
};
//page
/********************************************************************/
/********** ｌｏｇ table for ＬＵＴ *********/
/********** y = 256 * log255( x ) *********/
/********************************************************************/
static const BYTE log0tbl[0x100] = {
0, 0, 32, 50, 64, 74, 82, 89, 96, 101,
106, 110, 114, 118, 121, 125, 128, 130, 133, 135,
138, 140, 142, 144, 146, 148, 150, 152, 153, 155,
157, 158, 160, 161, 162, 164, 165, 166, 167, 169,
170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
180, 181, 182, 183, 184, 185, 185, 186, 187, 188,
189, 189, 190, 191, 192, 192, 193, 194, 194, 195,
196, 196, 197, 198, 198, 199, 199, 200, 201, 201,
202, 202, 203, 204, 204, 205, 205, 206, 206, 207,
207, 208, 208, 209, 209, 210, 210, 211, 211, 212,
212, 213, 213, 213, 214, 214, 215, 215, 216, 216,
217, 217, 217, 218, 218, 219, 219, 219, 220, 220,
221, 221, 221, 222, 222, 222, 223, 223, 224, 224,
224, 225, 225, 225, 226, 226, 226, 227, 227, 227,
228, 228, 228, 229, 229, 229, 230, 230, 230, 231,
231, 231, 231, 232, 232, 232, 233, 233, 233, 234,
234, 234, 234, 235, 235, 235, 236, 236, 236, 236,
237, 237, 237, 237, 238, 238, 238, 238, 239, 239,
239, 239, 240, 240, 240, 241, 241, 241, 241, 241,
242, 242, 242, 242, 243, 243, 243, 243, 244, 244,
244, 244, 245, 245, 245, 245, 245, 246, 246, 246,
246, 247, 247, 247, 247, 247, 248, 248, 248, 248,
249, 249, 249, 249, 249, 250, 250, 250, 250, 250,
251, 251, 251, 251, 251, 252, 252, 252, 252, 252,
253, 253, 253, 253, 253, 253, 254, 254, 254, 254,
254, 255, 255, 255, 255, 255,
};
//page
/********************************************************************/
/********** ｌｏｇ table for ＬＵＴ *********/
/********** y = 255 ** ( x / 255 ) *********/
/********************************************************************/
static const BYTE log1tbl[0x100] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 5, 5, 5, 5, 5,
5, 5, 5, 6, 6, 6, 6, 6, 6, 6,
7, 7, 7, 7, 7, 7, 8, 8, 8, 8,
8, 8, 9, 9, 9, 9, 10, 10, 10, 10,
10, 11, 11, 11, 11, 12, 12, 12, 13, 13,
13, 13, 14, 14, 14, 15, 15, 15, 16, 16,
16, 17, 17, 18, 18, 18, 19, 19, 20, 20,
20, 21, 21, 22, 22, 23, 23, 24, 24, 25,
26, 26, 27, 27, 28, 29, 29, 30, 31, 31,
32, 33, 33, 34, 35, 36, 36, 37, 38, 39,
40, 41, 42, 43, 43, 44, 45, 46, 47, 48,
50, 51, 52, 53, 54, 55, 57, 58, 59, 60,
62, 63, 65, 66, 67, 69, 70, 72, 74, 75,
77, 79, 80, 82, 84, 86, 88, 90, 92, 94,
96, 98, 100, 102, 104, 107, 109, 111, 114, 116,
119, 122, 124, 127, 130, 133, 136, 139, 142, 145,
148, 151, 155, 158, 162, 165, 169, 172, 176, 180,
184, 188, 192, 197, 201, 205, 210, 214, 219, 224,
229, 234, 239, 244, 250, 255,
};
const BYTE *pat; // 元パターンのポインタ
if( k <= 0 ){ // Γ補正：中央強調
pat = pow12; // パターン用テーブル
}else if( k == 1 ){ // Γ補正：周辺強調
pat = pow08; // パターン用テーブル
}else if( k == 2 ){ // ｌｏｇ補正：中央強調
pat = log0tbl; // パターン用テーブル
}else if( k == 3 ){ // 指数補正：周辺強調
pat = log1tbl; // パターン用テーブル
}else{ // 上記外なら
return( STI_FLG ); // 引数検査違反
} //
set_lut( pat, lut, sw ); // パターンのコピー
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear040.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「Make5Lut()」の【関数名】説明
「Make」は、作成するで
「Lut」は、勿論、ＬＵＴ変換用のＬＵＴです！
ココでは、「Make○○Lut」と枝番号○○で機能分けした内の
一つのＬＵＴパターン作成の意味です！
ここの○○＝５は、Γｌｏｇパターン作成
です！
定型のパターン書き込みです！
このイメージです！
（Ｂ）関数「int Make5Lut()」の【返値】説明
この関数内で明示的に検査しているのは、
仮引数「int k,」が、所定の値に成って
居るか如何かを判定し仕様外ならエラー「STI_FLG」を
返します！
最後まで実行時は、正常終了「END_STI」を返します！
（Ｃ）関数「Make5Lut()」の【仮引数】説明
int CopyClear::Make5Lut(
BYTE lut[], // 作成するＬＵＴ
int k, // Γ／ｌｏｇ選択子
int sw // 反転ｓｗ(0:無/1:反転)
){「BYTE lut[],」はＬＵＴを一次元配列として使用！
「int k,」は、選択肢≪０から３≫の値で対応する
パターンをＬＵＴに書き込みます！
「int sw」は、パターン左右反転書き込み指定スイッチ
です！
（Ｄ）関数「Make5Lut()」の【アルゴリズム】説明
){
/********************************************************************/
/********** Γ table for ＬＵＴ *********/
/********** y = 256 * ( x / 256 ) ** 1.2 *********/
/********************************************************************/
static const BYTE pow12[] = {
0, 0, 1, 1, 2, 2, 3, 3, 4, 5,
5, 6, 7, 7, 8, 9, 9, 10, 11, 11,
12, 13, 13, 14, 15, 16, 16, 17, 18, 19,
20, 20, 21, 22, 23, 24, 24, 25, 26, 27,
28, 28, 29, 30, 31, 32, 33, 33, 34, 35,
36, 37, 38, 39, 40, 40, 41, 42, 43, 44,
45, 46, 47, 48, 49, 49, 50, 51, 52, 53,
54, 55, 56, 57, 58, 59, 60, 61, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
124, 125, 126, 127, 128, 129, 130, 132, 133, 134,
135, 136, 137, 138, 139, 140, 141, 142, 143, 145,
146, 147, 148, 149, 150, 151, 152, 153, 154, 156,
157, 158, 159, 160, 161, 162, 163, 164, 166, 167,
168, 169, 170, 171, 172, 173, 174, 176, 177, 178,
179, 180, 181, 182, 184, 185, 186, 187, 188, 189,
190, 192, 193, 194, 195, 196, 197, 198, 200, 201,
202, 203, 204, 205, 206, 208, 209, 210, 211, 212,
213, 215, 216, 217, 218, 219, 220, 222, 223, 224,
225, 226, 227, 229, 230, 231, 232, 233, 235, 236,
237, 238, 239, 240, 242, 243, 244, 245, 246, 248,
249, 250, 251, 252, 254, 255,
};
/********************************************************************/
/********** Γ table for ＬＵＴ *********/
/********** y = 256 * ( x / 256 ) ** 0.8 *********/
/********************************************************************/
static const BYTE pow08[0x100] = {
0, 3, 5, 7, 9, 11, 13, 14, 16, 18,
19, 21, 22, 24, 25, 26, 28, 29, 31, 32,
33, 35, 36, 37, 39, 40, 41, 42, 44, 45,
46, 47, 49, 50, 51, 52, 53, 54, 56, 57,
58, 59, 60, 61, 63, 64, 65, 66, 67, 68,
69, 70, 72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, 86, 87, 88, 89, 90,
91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
121, 122, 123, 124, 125, 125, 126, 127, 128, 129,
130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
140, 141, 141, 142, 143, 144, 145, 146, 147, 148,
149, 150, 151, 152, 153, 153, 154, 155, 156, 157,
158, 159, 160, 161, 162, 162, 163, 164, 165, 166,
167, 168, 169, 170, 170, 171, 172, 173, 174, 175,
176, 177, 178, 178, 179, 180, 181, 182, 183, 184,
185, 185, 186, 187, 188, 189, 190, 191, 191, 192,
193, 194, 195, 196, 197, 197, 198, 199, 200, 201,
202, 203, 203, 204, 205, 206, 207, 208, 208, 209,
210, 211, 212, 213, 213, 214, 215, 216, 217, 218,
218, 219, 220, 221, 222, 223, 223, 224, 225, 226,
227, 228, 228, 229, 230, 231, 232, 233, 233, 234,
235, 236, 237, 237, 238, 239, 240, 241, 241, 242,
243, 244, 245, 246, 246, 247, 248, 249, 250, 250,
251, 252, 253, 254, 254, 255,
};
//page
/********************************************************************/
/********** ｌｏｇ table for ＬＵＴ *********/
/********** y = 256 * log255( x ) *********/
/********************************************************************/
static const BYTE log0tbl[0x100] = {
0, 0, 32, 50, 64, 74, 82, 89, 96, 101,
106, 110, 114, 118, 121, 125, 128, 130, 133, 135,
138, 140, 142, 144, 146, 148, 150, 152, 153, 155,
157, 158, 160, 161, 162, 164, 165, 166, 167, 169,
170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
180, 181, 182, 183, 184, 185, 185, 186, 187, 188,
189, 189, 190, 191, 192, 192, 193, 194, 194, 195,
196, 196, 197, 198, 198, 199, 199, 200, 201, 201,
202, 202, 203, 204, 204, 205, 205, 206, 206, 207,
207, 208, 208, 209, 209, 210, 210, 211, 211, 212,
212, 213, 213, 213, 214, 214, 215, 215, 216, 216,
217, 217, 217, 218, 218, 219, 219, 219, 220, 220,
221, 221, 221, 222, 222, 222, 223, 223, 224, 224,
224, 225, 225, 225, 226, 226, 226, 227, 227, 227,
228, 228, 228, 229, 229, 229, 230, 230, 230, 231,
231, 231, 231, 232, 232, 232, 233, 233, 233, 234,
234, 234, 234, 235, 235, 235, 236, 236, 236, 236,
237, 237, 237, 237, 238, 238, 238, 238, 239, 239,
239, 239, 240, 240, 240, 241, 241, 241, 241, 241,
242, 242, 242, 242, 243, 243, 243, 243, 244, 244,
244, 244, 245, 245, 245, 245, 245, 246, 246, 246,
246, 247, 247, 247, 247, 247, 248, 248, 248, 248,
249, 249, 249, 249, 249, 250, 250, 250, 250, 250,
251, 251, 251, 251, 251, 252, 252, 252, 252, 252,
253, 253, 253, 253, 253, 253, 254, 254, 254, 254,
254, 255, 255, 255, 255, 255,
};
//page
/********************************************************************/
/********** ｌｏｇ table for ＬＵＴ *********/
/********** y = 255 ** ( x / 255 ) *********/
/********************************************************************/
static const BYTE log1tbl[0x100] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 5, 5, 5, 5, 5,
5, 5, 5, 6, 6, 6, 6, 6, 6, 6,
7, 7, 7, 7, 7, 7, 8, 8, 8, 8,
8, 8, 9, 9, 9, 9, 10, 10, 10, 10,
10, 11, 11, 11, 11, 12, 12, 12, 13, 13,
13, 13, 14, 14, 14, 15, 15, 15, 16, 16,
16, 17, 17, 18, 18, 18, 19, 19, 20, 20,
20, 21, 21, 22, 22, 23, 23, 24, 24, 25,
26, 26, 27, 27, 28, 29, 29, 30, 31, 31,
32, 33, 33, 34, 35, 36, 36, 37, 38, 39,
40, 41, 42, 43, 43, 44, 45, 46, 47, 48,
50, 51, 52, 53, 54, 55, 57, 58, 59, 60,
62, 63, 65, 66, 67, 69, 70, 72, 74, 75,
77, 79, 80, 82, 84, 86, 88, 90, 92, 94,
96, 98, 100, 102, 104, 107, 109, 111, 114, 116,
119, 122, 124, 127, 130, 133, 136, 139, 142, 145,
148, 151, 155, 158, 162, 165, 169, 172, 176, 180,
184, 188, 192, 197, 201, 205, 210, 214, 219, 224,
229, 234, 239, 244, 250, 255,
};
const BYTE *pat; // 元パターンのポインタ
if( k <= 0 ){ // Γ補正：中央強調
pat = pow12; // パターン用テーブル
}else if( k == 1 ){ // Γ補正：周辺強調
pat = pow08; // パターン用テーブル
}else if( k == 2 ){ // ｌｏｇ補正：中央強調
pat = log0tbl; // パターン用テーブル
}else if( k == 3 ){ // 指数補正：周辺強調
pat = log1tbl; // パターン用テーブル
}else{ // 上記外なら
return( STI_FLG ); // 引数検査違反
} //
set_lut( pat, lut, sw ); // パターンのコピー
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
/********************************************************************/
/********** Γ table for ＬＵＴ *********/
/********** y = 256 * ( x / 256 ) ** 1.2 *********/
/********************************************************************/
static const BYTE pow12[] = {
0, 0, 1, 1, 2, 2, 3, 3, 4, 5,
5, 6, 7, 7, 8, 9, 9, 10, 11, 11,
12, 13, 13, 14, 15, 16, 16, 17, 18, 19,
20, 20, 21, 22, 23, 24, 24, 25, 26, 27,
28, 28, 29, 30, 31, 32, 33, 33, 34, 35,
36, 37, 38, 39, 40, 40, 41, 42, 43, 44,
45, 46, 47, 48, 49, 49, 50, 51, 52, 53,
54, 55, 56, 57, 58, 59, 60, 61, 61, 62,
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
124, 125, 126, 127, 128, 129, 130, 132, 133, 134,
135, 136, 137, 138, 139, 140, 141, 142, 143, 145,
146, 147, 148, 149, 150, 151, 152, 153, 154, 156,
157, 158, 159, 160, 161, 162, 163, 164, 166, 167,
168, 169, 170, 171, 172, 173, 174, 176, 177, 178,
179, 180, 181, 182, 184, 185, 186, 187, 188, 189,
190, 192, 193, 194, 195, 196, 197, 198, 200, 201,
202, 203, 204, 205, 206, 208, 209, 210, 211, 212,
213, 215, 216, 217, 218, 219, 220, 222, 223, 224,
225, 226, 227, 229, 230, 231, 232, 233, 235, 236,
237, 238, 239, 240, 242, 243, 244, 245, 246, 248,
249, 250, 251, 252, 254, 255,
};
/********************************************************************/
/********** Γ table for ＬＵＴ *********/
/********** y = 256 * ( x / 256 ) ** 0.8 *********/
/********************************************************************/
static const BYTE pow08[0x100] = {
0, 3, 5, 7, 9, 11, 13, 14, 16, 18,
19, 21, 22, 24, 25, 26, 28, 29, 31, 32,
33, 35, 36, 37, 39, 40, 41, 42, 44, 45,
46, 47, 49, 50, 51, 52, 53, 54, 56, 57,
58, 59, 60, 61, 63, 64, 65, 66, 67, 68,
69, 70, 72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, 86, 87, 88, 89, 90,
91, 92, 93, 94, 95, 96, 97, 98, 99, 100,
101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
121, 122, 123, 124, 125, 125, 126, 127, 128, 129,
130, 131, 132, 133, 134, 135, 136, 137, 138, 139,
140, 141, 141, 142, 143, 144, 145, 146, 147, 148,
149, 150, 151, 152, 153, 153, 154, 155, 156, 157,
158, 159, 160, 161, 162, 162, 163, 164, 165, 166,
167, 168, 169, 170, 170, 171, 172, 173, 174, 175,
176, 177, 178, 178, 179, 180, 181, 182, 183, 184,
185, 185, 186, 187, 188, 189, 190, 191, 191, 192,
193, 194, 195, 196, 197, 197, 198, 199, 200, 201,
202, 203, 203, 204, 205, 206, 207, 208, 208, 209,
210, 211, 212, 213, 213, 214, 215, 216, 217, 218,
218, 219, 220, 221, 222, 223, 223, 224, 225, 226,
227, 228, 228, 229, 230, 231, 232, 233, 233, 234,
235, 236, 237, 237, 238, 239, 240, 241, 241, 242,
243, 244, 245, 246, 246, 247, 248, 249, 250, 250,
251, 252, 253, 254, 254, 255,
};
//page
/********************************************************************/
/********** ｌｏｇ table for ＬＵＴ *********/
/********** y = 256 * log255( x ) *********/
/********************************************************************/
static const BYTE log0tbl[0x100] = {
0, 0, 32, 50, 64, 74, 82, 89, 96, 101,
106, 110, 114, 118, 121, 125, 128, 130, 133, 135,
138, 140, 142, 144, 146, 148, 150, 152, 153, 155,
157, 158, 160, 161, 162, 164, 165, 166, 167, 169,
170, 171, 172, 173, 174, 175, 176, 177, 178, 179,
180, 181, 182, 183, 184, 185, 185, 186, 187, 188,
189, 189, 190, 191, 192, 192, 193, 194, 194, 195,
196, 196, 197, 198, 198, 199, 199, 200, 201, 201,
202, 202, 203, 204, 204, 205, 205, 206, 206, 207,
207, 208, 208, 209, 209, 210, 210, 211, 211, 212,
212, 213, 213, 213, 214, 214, 215, 215, 216, 216,
217, 217, 217, 218, 218, 219, 219, 219, 220, 220,
221, 221, 221, 222, 222, 222, 223, 223, 224, 224,
224, 225, 225, 225, 226, 226, 226, 227, 227, 227,
228, 228, 228, 229, 229, 229, 230, 230, 230, 231,
231, 231, 231, 232, 232, 232, 233, 233, 233, 234,
234, 234, 234, 235, 235, 235, 236, 236, 236, 236,
237, 237, 237, 237, 238, 238, 238, 238, 239, 239,
239, 239, 240, 240, 240, 241, 241, 241, 241, 241,
242, 242, 242, 242, 243, 243, 243, 243, 244, 244,
244, 244, 245, 245, 245, 245, 245, 246, 246, 246,
246, 247, 247, 247, 247, 247, 248, 248, 248, 248,
249, 249, 249, 249, 249, 250, 250, 250, 250, 250,
251, 251, 251, 251, 251, 252, 252, 252, 252, 252,
253, 253, 253, 253, 253, 253, 254, 254, 254, 254,
254, 255, 255, 255, 255, 255,
};
//page
/********************************************************************/
/********** ｌｏｇ table for ＬＵＴ *********/
/********** y = 255 ** ( x / 255 ) *********/
/********************************************************************/
static const BYTE log1tbl[0x100] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 4, 4, 4, 4, 4, 4,
4, 4, 4, 4, 4, 5, 5, 5, 5, 5,
5, 5, 5, 6, 6, 6, 6, 6, 6, 6,
7, 7, 7, 7, 7, 7, 8, 8, 8, 8,
8, 8, 9, 9, 9, 9, 10, 10, 10, 10,
10, 11, 11, 11, 11, 12, 12, 12, 13, 13,
13, 13, 14, 14, 14, 15, 15, 15, 16, 16,
16, 17, 17, 18, 18, 18, 19, 19, 20, 20,
20, 21, 21, 22, 22, 23, 23, 24, 24, 25,
26, 26, 27, 27, 28, 29, 29, 30, 31, 31,
32, 33, 33, 34, 35, 36, 36, 37, 38, 39,
40, 41, 42, 43, 43, 44, 45, 46, 47, 48,
50, 51, 52, 53, 54, 55, 57, 58, 59, 60,
62, 63, 65, 66, 67, 69, 70, 72, 74, 75,
77, 79, 80, 82, 84, 86, 88, 90, 92, 94,
96, 98, 100, 102, 104, 107, 109, 111, 114, 116,
119, 122, 124, 127, 130, 133, 136, 139, 142, 145,
148, 151, 155, 158, 162, 165, 169, 172, 176, 180,
184, 188, 192, 197, 201, 205, 210, 214, 219, 224,
229, 234, 239, 244, 250, 255,
};
const BYTE *pat; // 元パターンのポインタ
「static const BYTE pow12[]={・・中身・・};」は、
勿論、「static const BYTE ・・[]」と固定データテーブル
で「１．２」を冪指数とする冪演算
で作成した低を０から２５５までの値とする
テーブルです！※備考※「pow12[]」と「[]」と中身を省略
してこのテーブルは記載して居ます＝定数値の数が「[]」
の中身を指定した事と同じです！
「static const BYTE pow08[0x100]={・・中身・・
};」は、勿論、「static const BYTE ・・[]」と固定データテーブル
で「０．８」を冪指数とする冪演算
で作成した低を０から２５５までの値とする
テーブルです！※備考※「pow08[0x100]」と「[0x100]」と
中身を明示的に記載し、「0x100＝256」とヘキサ表示で
８ビット目いっぱい使用して居る事を示して居ます！と説明
の為の記法で「覚書」として記載した心算！
「static const BYTE log0tbl[0x100]={・・中身・・
};」は、ログ対数関数を使用した０～２５５内を凸方向に
カーブしたパターン！
「static const BYTE log1tbl[0x100]={・・中身・・
};」は、ログ対数関数を使用した０～２５５内を凹方向に
カーブしたパターン！
「const BYTE *pat;」は、テーブルのパターンを
ポインタで取り出し、コピーする時に使用するポインタ変数
（Ｄ－２）アルゴリズムコード
if( k <= 0 ){ // Γ補正：中央強調
pat = pow12; // パターン用テーブル
}else if( k == 1 ){ // Γ補正：周辺強調
pat = pow08; // パターン用テーブル
}else if( k == 2 ){ // ｌｏｇ補正：中央強調
pat = log0tbl; // パターン用テーブル
}else if( k == 3 ){ // 指数補正：周辺強調
pat = log1tbl; // パターン用テーブル
}else{ // 上記外なら
return( STI_FLG ); // 引数検査違反
} //
set_lut( pat, lut, sw ); // パターンのコピー
return( END_STI ); // 正常終了
}「if(k<=0){pat=pow12;}else if(k==1){pat=pow08;}
else if(k==2){pat=log0tbl;}else if(k==3){pat=log1tbl;
}else{return(STI_FLG);}」は、仮引数「int k,」が０の
場合、ローカルポインタ変数「pat」に
テーブル「pow12」をセット、同じく１の場合、変数に
テーブル「pow08」をセット、同じく２の場合、変数に
テーブル「log0tbl」をセット、同じく３の場合、変数に
テーブル「log0tbl」をセット、同じく４の場合、変数に
テーブル「log1tbl」をセット、それ以外ならば、
「return(STI_FLG);」とエラーコードを返し関数終了
「set_lut(pat,lut,sw);」は、サブルーチン関数「
set_lut();」でＬＵＴにパターンをセット！
「return(END_STI);」は、正常終了を返し関数終了
（Ｅ）関数「Make5Lut()」の【使用例】
★注意★
使用例は、別の解説エッセイ『ＬＵＴ使用例』で別途説明す
る事に方針変換しました！使用例発表まで乞うご期待と記載
して置きます！
（４－１４－３１）関数「int Make6Lut(BYTE lut[],int k,int col){・・・｝」の説明
/************************************************************************/
/***** ＬＵＴデータの作成：疑似カラーパターン *****/
/***** 返し値：エラーチェックの値（END_STI,STI_FLG） *****/
/***** 注意① パターン選択子省略時（負値）→０ *****/
/***** 注意② 色選択子省略時（負値） →０ *****/
/************************************************************************/
int CopyClear::Make6Lut(
BYTE lut[], // 作成するＬＵＴ
int k, // Pattern選択子 0..9
// 0:8色, 1:16色
// 2..5:32..256色:寒暖系
// 6..9:32..256色:色相系
int col // 色選択子 0:R,1:G,2:B
){
if( col < 0 ){ // 色指定が、省略時は、
col = 0; // Ｒにセットし
}else if( col > 2 ){ // 色の範囲外なら
return( STI_FLG ); // 引数検査違反
} //
if( k <= 0 ){ // ８色疑似カラー
lut_6_0( lut, col ); // 上記Patternの作成
}else if( k == 1 ){ // １６色疑似カラー
lut_6_1( lut, col ); // 上記Patternの作成
}else if( k >= 2 && k <= 5 ){ // 寒色→暖色疑似Col
lut_6_2( lut, col ); // 寒暖256色Dataの設定
lut_6_4( lut, k - 2 ); // 32/64/128色へ圧縮
}else if( k >= 6 && k <= 9 ){ // 色相疑似カラー
lut_6_3( lut, col ); // 色差256色Dataの設定
lut_6_4( lut, k - 6 ); // 32/64/128色へ圧縮
}else if( k == 10 ){ // 色抽出疑似Col：ＲＧＢ
lut_6_10( lut, col ); // 色抽出:ＲＧＢ用を作成
}else if( k == 11 ){ // 色抽出疑似Col：ＲＧＢ
lut_6_11( lut, col ); // 色抽出：色差用を作成
}else{ // Patternの範囲外なら
return( STI_FLG ); // 引数検査違反
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear040.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「Make6Lut()」の【関数名】説明
「Make」は、作成するで
「Lut」は、勿論、ＬＵＴ変換用のＬＵＴです！
ココでは、「Make○○Lut」と枝番号○○で機能分けした内の
一つのＬＵＴパターン作成の意味です！
ここの○○＝６は、疑似カラー表示用ＬＵＴパターン作成用
です！モノクロ画素（白黒濃淡）画像からＲＧＢ３色３枚の
画像メモリを疑似カラー表示用に生成する為のＬＵＴの
パターンを作成します！
（Ｂ）関数「int Make6Lut()」の【返値】説明
この関数内で明示的に検査しているのは、
仮引数「int col」が、所定の値≪Ｒ（赤）を示す「0」・
Ｇ（緑）を示す「1」・Ｂ（青）を示す「2」≫に成って居る
か否かでエラーならエラーコード「STI_FLG」を辺値！
仮引数「int k,」が、所定の値≪１１以下≫に成って
居るか如何かを判定し仕様外ならエラー「STI_FLG」を
返します！
最後まで実行時は、正常終了「END_STI」を返します！
（Ｃ）関数「Make6Lut()」の【仮引数】説明
int CopyClear::Make6Lut(
BYTE lut[], // 作成するＬＵＴ
int k, // Pattern選択子 0..9
// 0:8色, 1:16色
// 2..5:32..256色:寒暖系
// 6..9:32..256色:色相系
int col // 色選択子 0:R,1:G,2:B
){「BYTE lut[],」はＬＵＴを一次元配列として使用！
「int k,」は、選択肢≪０以下ならば、「８色疑似カラー
パターン」そして「１から１１」ならモット細かい疑似
カラーパターン≫の値で対応する処理を実行！
パターンをＬＵＴに書き込みます！
「int col」は、色選択肢≪Ｒ（赤）を示す「0」・Ｇ（緑）
を示す「1」・Ｂ（青）を示す「2」≫で選択します！
（Ｄ）関数「Make6Lut()」の【アルゴリズム】説明
){
if( col < 0 ){ // 色指定が、省略時は、
col = 0; // Ｒにセットし
}else if( col > 2 ){ // 色の範囲外なら
return( STI_FLG ); // 引数検査違反
} //
if( k <= 0 ){ // ８色疑似カラー
lut_6_0( lut, col ); // 上記Patternの作成
}else if( k == 1 ){ // １６色疑似カラー
lut_6_1( lut, col ); // 上記Patternの作成
}else if( k >= 2 && k <= 5 ){ // 寒色→暖色疑似Col
lut_6_2( lut, col ); // 寒暖256色Dataの設定
lut_6_4( lut, k - 2 ); // 32/64/128色へ圧縮
}else if( k >= 6 && k <= 9 ){ // 色相疑似カラー
lut_6_3( lut, col ); // 色差256色Dataの設定
lut_6_4( lut, k - 6 ); // 32/64/128色へ圧縮
}else if( k == 10 ){ // 色抽出疑似Col：ＲＧＢ
lut_6_10( lut, col ); // 色抽出:ＲＧＢ用を作成
}else if( k == 11 ){ // 色抽出疑似Col：ＲＧＢ
lut_6_11( lut, col ); // 色抽出：色差用を作成
}else{ // Patternの範囲外なら
return( STI_FLG ); // 引数検査違反
} //
return( END_STI ); // 正常終了
}「if(col<0){col=0;}else if(col>2){
return(STI_FLG);}」は、条件「col<0」の場合、
「col=0;」と仮引数「int col」を「0」にセットし、
次条件「col>2」と２を越えたら「return(STI_FLG);」と
エラーコード「STI_FLG」を返し関数終了！
１番目条件「k<=0」成立時、「lut_6_0(lut,col);」と
サブルーチン関数「lut_6_0()」で８色疑似カラーパターン
作成！
２番目条件「k==1」成立時、「lut_6_1(lut,col);」と
サブルーチン関数「lut_6_1()」で１６色疑似カラー
パターン作成！
３番目条件「k>=2&&k<=5」成立時≪２から５の場合≫、
「lut_6_2(lut,col);lut_6_4(lut,k-2);」と
「寒色⇒暖色」パターンをサブルーチン関数「lut_6_2()」
で作成しとサブルーチン関数「lut_6_4()」で諧調圧縮を
かけます！
４番目条件「k>=6&&k<=9」成立時≪６から９の場合≫、
「lut_6_3(lut,col);lut_6_4(lut,k-2);」と
色相疑似カラーパターンをサブルーチン関数
「lut_6_3()」で作成しとサブルーチン関数
「lut_6_4()」で諧調色抽出をかけます！
５番目条件「k==10」成立時、「lut_6_10(lut,col);」と
サブルーチン関数「lut_6_10()」で色（ＲＧＢ系）抽出用
疑似カラーパターンを作成！
６番目条件「k==11」成立時、「lut_6_11(lut,col);」と
サブルーチン関数「lut_6_11()」で色（色差系）抽出用
疑似カラーパターンを作成！
「return(END_STI);」は、正常終了を返し関数終了！
（Ｅ）関数「Make6Lut()」の【使用例】
★注意★
使用例は、別の解説エッセイ『ＬＵＴ使用例』で別途説明す
る事に方針変換しました！使用例発表まで乞うご期待と記載
して置きます！
（４－１４－３２）関数「int Make7Lut(BYTE *lut,int bit,int data){・・・｝」の説明
/************************************************************************/
/***** ＬＵＴデータの作成：ビットスライスパターン *****/
/***** 返し値：エラーチェックの値（END_STI,STI_FLG） *****/
/***** 注意① ビット位置省略時（負値） →０ *****/
/***** 注意② 出力データ省略時（負値） →１ *****/
/************************************************************************/
int CopyClear::Make7Lut(
BYTE *lut, // 作成するＬＵＴ
int bit, // ビット位置 0..7
int data // 出力データ 0..255
){
int i; // カウンタ 0..255
int mask; // ビット位置のマスク
if( bit < 0 ){ // ビット位置省略時
bit = 0; // ０をビット位置にし
mask = 1; // １をMaskDataにする
}else if( bit <= 7 ){ // 0..7 の範囲内なら
mask = 1 << bit; // 左記でMaskData算出
}else{ // 範囲外なら
return( STI_FLG ); // 引数検査違反
} //
if( data < 0 ){ // 出力値省略時
data = 1; // １を出力値にする
}else if( data > 255 ){ // 0..255 の範囲外なら
return( STI_FLG ); // 引数検査違反
} //
up_fill_void( 0, lut, 256 ); // ＬＵＴを一旦０クリア
for( i = 0; i <= 255; i++ ){ // 0..255の間で
*lut++ = ( (i & mask) >> bit ) * data; // スライスパターン作成
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear040.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「int Make7Lut()」の【関数名】説明
「Make」は、作成するで
「Lut」は、勿論、ＬＵＴ変換用のＬＵＴです！
ココでは、「Make○○Lut」と枝番号○○で機能分けした内の
一つのＬＵＴパターン作成の意味です！
ここの○○＝７は、ビットスライスパターン作成用
です！
（Ｂ）関数「Make7Lut()」の【返値】説明
この関数内で明示的に検査しているのは、
仮引数「int bit,」が、ビット位置≪８ビット画像用なので
０から７≫に成って居るか否かでエラーならエラーコード
「STI_FLG」を辺値とし関数終了！
仮引数「int data」が、所定の値≪８ビット画像用なので
０から２５５と画素の書き込むデータ値≫に成って居るか
如何かを判定し仕様外ならエラー「STI_FLG」を返します！
最後まで実行時は、正常終了「END_STI」を返します！
（Ｃ）関数「Make7Lut()」の【仮引数】説明
int CopyClear::Make7Lut(
BYTE *lut, // 作成するＬＵＴ
int bit, // ビット位置 0..7
int data // 出力データ 0..255
){「BYTE* lut,」はＬＵＴを一次元配列として使用！
「int bit,」は、ビット位置≪８ビット画像用なので
０から７≫
「int data」は、値≪８ビット画像用なので０から
２５５と画素の書き込むデータ値≫
（Ｄ）関数「Make7Lut()」の【アルゴリズム】説明
){
int i; // カウンタ 0..255
int mask; // ビット位置のマスク
if( bit < 0 ){ // ビット位置省略時
bit = 0; // ０をビット位置にし
mask = 1; // １をMaskDataにする
}else if( bit <= 7 ){ // 0..7 の範囲内なら
mask = 1 << bit; // 左記でMaskData算出
}else{ // 範囲外なら
return( STI_FLG ); // 引数検査違反
} //
if( data < 0 ){ // 出力値省略時
data = 1; // １を出力値にする
}else if( data > 255 ){ // 0..255 の範囲外なら
return( STI_FLG ); // 引数検査違反
} //
up_fill_void( 0, lut, 256 ); // ＬＵＴを一旦０クリア
for( i = 0; i <= 255; i++ ){ // 0..255の間で
*lut++ = ( (i & mask) >> bit ) * data; // スライスパターン作成
} //
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
int i; // カウンタ 0..255
int mask; // ビット位置のマスク「int i;」は、ループカウンタ≪０・・２５５≫
「int mask;」は、ビット位置をマスクする値
（Ｄ－２）アルゴリズムコード
if( bit < 0 ){ // ビット位置省略時
bit = 0; // ０をビット位置にし
mask = 1; // １をMaskDataにする
}else if( bit <= 7 ){ // 0..7 の範囲内なら
mask = 1 << bit; // 左記でMaskData算出
}else{ // 範囲外なら
return( STI_FLG ); // 引数検査違反
} //
if( data < 0 ){ // 出力値省略時
data = 1; // １を出力値にする
}else if( data > 255 ){ // 0..255 の範囲外なら
return( STI_FLG ); // 引数検査違反
} //
up_fill_void( 0, lut, 256 ); // ＬＵＴを一旦０クリア
for( i = 0; i <= 255; i++ ){ // 0..255の間で
*lut++ = ( (i & mask) >> bit ) * data; // スライスパターン作成
} //
return( END_STI ); // 正常終了
}「if(bit<0){bit=0;mask=1;}
else if(bit<=7){mask=1<<bit;}
else{return(STI_FLG);}」は、
最初の条件「bit<0」で成立時「bit=0;mask=1;」とセット
２番の条件「bit<=7」で成立時「mask=1<<bit;」と演算！
「else」と条件不成立「return(STI_FLG);」とエラーコー
ド「STI_FLG」を返し関数終了！
「if(data<0){data=1;}else if(data>255){
return(STI_FLG);}」は、最初の条件「data<0」で
成立時「data=1;」とセット
２番の条件「data>255」詰り≪２５５と８ビットの値を
超える場合≫で「return(STI_FLG);」とエラーコード
「STI_FLG」を返し関数終了！
「up_fill_void (0,lut,256);」は、一旦、ＬＵＴ配列を
０クリア、
「for(i=0;i<=255;i++){*lut++=((i&mask)>>bit)*data;}」
は、ｆｏｒループ定番「i=0;i<=255;i++」と０から２５５
まで繰り返し、
ループ中身「*lut++=((i&mask)>>bit)*data;」で
ビットスライスパターンを発生！※備考※使用例で確認
して下さい！
「return(END_STI);」は、正常終了！
（Ｅ）関数「Make7Lut()」の【使用例】
★注意★
使用例は、別の解説エッセイ『ＬＵＴ使用例』で別途説明す
る事に方針変換しました！使用例発表まで乞うご期待と記載
して置きます！
（４－１４－３３）関数「int Make8Lut(BYTE lut[],int k,int sw){・・・｝」の説明
/************************************************************************/
/***** ＬＵＴデータの作成：任意Γパターン *****/
/***** 返し値：エラーチェックの値（END_STI,STI_FLG） *****/
/***** 計算式：y = 256 * ( x / 256 ) ** r *****/
/************************************************************************/
int CopyClear::Make8Lut(
BYTE lut[], // 作成するＬＵＴ
int k, // 係数1～100→0.1～10.0
int sw // 反転ｓｗ(0:無/1:反転)
){
BYTE buf[ 256 ]; // パターンバッファー
BYTE *ptr; // 上記へのポインタ
double r; // 0.01～10.0
double dt_256; // 定数：256.0：高速化
double dv_256; // 上記の逆数
double x; // 0.0～255.0/256.0
double y; // Γ＝256.0×pow(x,r)
int i; // カウンタ 0..255
if( k < 1 || k > 1000 ){ // 範囲検査で不正なら
return( STI_FLG ); // 引数検査違反
} //
r = (double)k * 0.01; // 1～1000→0.01～10.00
dt_256 = 256.0; // 定数：256.0：高速化
dv_256 = 1.0 / 256.0; // 256.0の逆数をセット
ptr = buf; // ポインタをセット
for( i = 0; i < 256; i++ ){ // 0..255の間で
x = (double)i * dv_256; // 1.0/256.0刻みを算出し
y = dt_256 * pow( x, r ); // Γ値を算出し
if( y >= dt_256 ){ // 256.0以上なら
*ptr++ = 255; // 255を格納し
}else{ // 上記以外なら
*ptr++ = (int)( y + 0.5 ); // 四捨五入し格納
} //
} //
set_lut( buf, lut, sw ); // パターンのコピー
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear040.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「Make8Lut()」の【関数名】説明
「Make」は、作成するで
「Lut」は、勿論、ＬＵＴ変換用のＬＵＴです！
ココでは、「Make○○Lut」と枝番号○○で機能分けした内の
一つのＬＵＴパターン作成の意味です！
ここの○○＝８は、任意Γパターン作成用です！
計算式「y=256*(x/256)**r」に従いパターンを
作成します！「**」演算子は、べき乗です！
（Ｂ）関数「int Make8Lut()」の【返値】説明
この関数内で明示的に検査しているのは、
仮引数「int k,」が、範囲「1..100」に成って居るか否かで
エラーならエラーコード「STI_FLG」を辺値とし関数終了！
最後まで実行時は、正常終了「END_STI」を返します！
（Ｃ）関数「Make8Lut()」の【仮引数】説明
int CopyClear::Make8Lut(
BYTE lut[], // 作成するＬＵＴ
int k, // 係数1～100→0.1～10.0
int sw // 反転ｓｗ(0:無/1:反転)
){「BYTE lut[],」はＬＵＴを一次元配列として使用！
「int k,」は、係数「１．．１００」で内部では、
「(double)k*0.01」と「0.01」を乗算し
「0.01から1.0」の値を係数として使用
「int sw」は、左右反転スイッチ⇒真なら左右反転
（Ｄ）関数「Make8Lut()」の【アルゴリズム】説明
){
BYTE buf[ 256 ]; // パターンバッファー
BYTE *ptr; // 上記へのポインタ
double r; // 0.01～10.0
double dt_256; // 定数：256.0：高速化
double dv_256; // 上記の逆数
double x; // 0.0～255.0/256.0
double y; // Γ＝256.0×pow(x,r)
int i; // カウンタ 0..255
if( k < 1 || k > 1000 ){ // 範囲検査で不正なら
return( STI_FLG ); // 引数検査違反
} //
r = (double)k * 0.01; // 1～1000→0.01～10.00
dt_256 = 256.0; // 定数：256.0：高速化
dv_256 = 1.0 / 256.0; // 256.0の逆数をセット
ptr = buf; // ポインタをセット
for( i = 0; i < 256; i++ ){ // 0..255の間で
x = (double)i * dv_256; // 1.0/256.0刻みを算出し
y = dt_256 * pow( x, r ); // Γ値を算出し
if( y >= dt_256 ){ // 256.0以上なら
*ptr++ = 255; // 255を格納し
}else{ // 上記以外なら
*ptr++ = (int)( y + 0.5 ); // 四捨五入し格納
} //
} //
set_lut( buf, lut, sw ); // パターンのコピー
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
BYTE buf[ 256 ]; // パターンバッファー
BYTE *ptr; // 上記へのポインタ
double r; // 0.01～10.0
double dt_256; // 定数：256.0：高速化
double dv_256; // 上記の逆数
double x; // 0.0～255.0/256.0
double y; // Γ＝256.0×pow(x,r)
int i; // カウンタ 0..255「BYTE buf[256];」は、ローカルに使用するパターンバッ
ファ！
「BYTE ptr;」は、上記バッファを操作するポインタ！
「double r;」は、内部で使用する係数
「double dt_256;」は、定数「256.0」☆注意☆アルゴ
リズム中に定数を直接記載するより早く成るコードが生成さ
れる事が多いのでコノ記法を使用！
「double dv_256;」は、「256.0」の除算用逆数値☆除算
より乗算の方が往々にして速度が早く成るので使用！
「double x;」は、Ｘ座標方向≪ＬＵＴ変換を二次元表現
すると、変換前の入力をＸ座標、変換後をＹ座標とした
グラフに成るのでコノ表現≫
「double y;」は、Ｘ座標方向≪上記の説明を参考≫
「int i;」は、ｆｏｒ構文用ループ変数！
（Ｄ－２）アルゴリズムコード
if( k < 1 || k > 1000 ){ // 範囲検査で不正なら
return( STI_FLG ); // 引数検査違反
} //
r = (double)k * 0.01; // 1～1000→0.01～10.00
dt_256 = 256.0; // 定数：256.0：高速化
dv_256 = 1.0 / 256.0; // 256.0の逆数をセット
ptr = buf; // ポインタをセット
for( i = 0; i < 256; i++ ){ // 0..255の間で
x = (double)i * dv_256; // 1.0/256.0刻みを算出し
y = dt_256 * pow( x, r ); // Γ値を算出し
if( y >= dt_256 ){ // 256.0以上なら
*ptr++ = 255; // 255を格納し
}else{ // 上記以外なら
*ptr++ = (int)( y + 0.5 ); // 四捨五入し格納
} //
} //
set_lut( buf, lut, sw ); // パターンのコピー
return( END_STI ); // 正常終了
}「if(k<1||k>1000){return(STI_FLG);}」は、
仮引数「int k,」の範囲検査です！範囲≪１から１００≫
の範囲外ならば、エラーコード「STI_FLG」を返し関数終了
「r=(double)k0.01;」は、係数「r」を仮引数「int k,」
を百分の一にしてセット！
「dt_256=256.0;dv_256=1.0/256.0;」は、定数セット！
「ptr=buf;」は、パターン格納用ポインタをセット！
「for(i=0;i<256;i++){・・ループ中身・・}」は、勿論、
教科書的な標準的なｆｏｒループでループカウンタ「i」を
昇順に「０から２５５」までカウントアップしながら、
ループ中身を実行します！★注意★散々、モット、トリッ
キーな方法で早く動作させる為にはと記載して居ますが、
コンな普通の方法を使用して居るのは「分かり易い」からで
す！そしてループ中身の方が処理時間が圧倒的に掛かるので
少々早い記載をしても無意味で更に２５６回しか繰り返さ無
いので相対的に「分かり易い」方を選んだと説明します！
更に中身で「x=(double)idv_256;」とループカウンタの
値「i」を重要なカウントアップする値として使用して居る
のｆｏｒループを採用した理由です！
ではループ中身の解説を行います！
「x=(double)idv_256;」は、グラフＸ座標に相当する
値を算出！
「y=dt_256*pow(x,r);」は、上記で作成したグラフＸ座標
と係数「r」でＸのｒべき乗演算を任意Γパターンとして
グラフＹ座標を示す変数「y」に格納！
「if(y>=dt_256){*ptr++=255;}else{
*ptr++=(int )(y+0.5);}」は、条件≪変数「y」の値が
「256.0」以上ならば≫条件成立「*ptr++=255;」と上限を
越えたとして「255」をパターン書き込み、
条件不成立「*ptr++=(int )(y+0.5);」で変数「y」の値を
「(int )(y+0.5)」で四捨五入してから整数値変換を行い
パターン書き込み！
「set_lut(buf,lut,sw);」は、ローカルパターンを
仮引数「BYTE lut[],」を介して実引数に値をセット！
「return(END_STI);」は、関数正常終了！
（Ｅ）関数「Make8Lut()」の【使用例】
★注意★
使用例は、別の解説エッセイ『ＬＵＴ使用例』で別途説明す
る事に方針変換しました！使用例発表まで乞うご期待と記載
して置きます！
（４－１４－３４）関数「int Make9Lut(BYTE lut[],int k){・・・｝」の説明
/************************************************************************/
/***** ＬＵＴデータの作成：階調圧縮パターン *****/
/************************************************************************/
int CopyClear::Make9Lut(
BYTE lut[], // 作成するＬＵＴ
int k // 圧縮段数 1..256
){
BYTE *p; // ＬＵＴへのポインタ
BYTE *pend; // ポインタ終点
int step; // ステップ数
int d; // データ
int d255; // 定数２５５：高速化用
int i; // カウンタ
if( k < 1 || k > 256 ){ // 範囲検査で不正なら
return( STI_FLG ); // 引数検査違反
} //
p = lut; // ポインタをセット
pend = &lut[255]; // 終点をセット
step = 256 / k; // ステップ数算出
d = 0; // データ初期化
d255 = 255; // 定数２５５：高速化用
while( --k >= 0 ){ // 段数分
for( i = step; --i >= 0; ){ // ステップ単位で
*p++ = d; // データを書き込み
} //
d += step; // データをStepUp
if( d > d255 ){ // 255を超えたらば
d = d255; // 255に補正
} //
} //
while( p <= pend ){ // 残りの部分を
*p++ = d; // データ書き込み
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear040.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「Make9Lut()」の【関数名】説明
「Make」は、作成するで
「Lut」は、勿論、ＬＵＴ変換用のＬＵＴです！
ココでは、「Make○○Lut」と枝番号○○で機能分けした内の
一つのＬＵＴパターン作成の意味です！
ここの○○＝９は、階調色抽出パターン作成用です！
★注意★上記の様に階段状のパターンです
（Ｂ）関数「int Make9Lut()」の【返値】説明
この関数内で明示的に検査しているのは、
仮引数「int k,」が、範囲「1..256」に成って居るか否かで
エラーならエラーコード「STI_FLG」を辺値とし関数終了！
最後まで実行時は、正常終了「END_STI」を返します！
（Ｃ）関数「Make9Lut()」の【仮引数】説明
int CopyClear::Make9Lut(
BYTE lut[], // 作成するＬＵＴ
int k // 圧縮段数 1..256
){「BYTE lut[],」はＬＵＴを一次元配列として使用！
「int k」は、色抽出段数「１．．２５６」で諧調色抽出する
段数を指定します！
（Ｄ）関数「Make9Lut()」の【アルゴリズム】説明
){
BYTE *p; // ＬＵＴへのポインタ
BYTE *pend; // ポインタ終点
int step; // ステップ数
int d; // データ
int d255; // 定数２５５：高速化用
int i; // カウンタ
if( k < 1 || k > 256 ){ // 範囲検査で不正なら
return( STI_FLG ); // 引数検査違反
} //
p = lut; // ポインタをセット
pend = &lut[255]; // 終点をセット
step = 256 / k; // ステップ数算出
d = 0; // データ初期化
d255 = 255; // 定数２５５：高速化用
while( --k >= 0 ){ // 段数分
for( i = step; --i >= 0; ){ // ステップ単位で
*p++ = d; // データを書き込み
} //
d += step; // データをStepUp
if( d > d255 ){ // 255を超えたらば
d = d255; // 255に補正
} //
} //
while( p <= pend ){ // 残りの部分を
*p++ = d; // データ書き込み
} //
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
BYTE *p; // ＬＵＴへのポインタ
BYTE *pend; // ポインタ終点
int step; // ステップ数
int d; // データ
int d255; // 定数２５５：高速化用
int i; // カウンタ「BYTE *p;」は、バッファを操作するポインタ！
「BYTE *pend;」は、バッファを操作するポインタ終点！
「int step;」は、ステップ数！
「int d;」は、書き込むデータ！
「int d255;」は、定数値「255」★注意★高速化用です！
「int i;」は、ｆｏｒ構文用ループ変数！
（Ｄ－２）アルゴリズムコード
if( k < 1 || k > 256 ){ // 範囲検査で不正なら
return( STI_FLG ); // 引数検査違反
} //
p = lut; // ポインタをセット
pend = &lut[255]; // 終点をセット
step = 256 / k; // ステップ数算出
d = 0; // データ初期化
d255 = 255; // 定数２５５：高速化用
while( --k >= 0 ){ // 段数分
for( i = step; --i >= 0; ){ // ステップ単位で
*p++ = d; // データを書き込み
} //
d += step; // データをStepUp
if( d > d255 ){ // 255を超えたらば
d = d255; // 255に補正
} //
} //
while( p <= pend ){ // 残りの部分を
*p++ = d; // データ書き込み
} //
return( END_STI ); // 正常終了
}「if(k<1||k>256){return(STI_FLG);}」は、
色抽出段数「int k」が１．．２５６の範囲外ならば、エラー
コード「STI_FLG」を返し関数終了！
「p=lut;pend=&lut[255];」は、操作ポインタの初期値と
ポインタ終点のセットです！
「step=256/k;d=0;d255=255;」は、「step」に一段当りの
データ書き込み数を算出しセット、「d」書き込みデータの
初期値セット、定数値「255」セット！
「while(--k>=0){・・外側ループ中身・・}」は、
★備考★「while(--k>=0」の様に「--k>=0」とデクリ
メント演算子で変数値が変化しても影響が無い応用には、
経験上最適なＣＰＵ機械コードが生成出来るので、
この画像処理ライブラリは、この記法を多用して居ます！
学校の教科書的には余り教えて無い（恐らく変数の値が変わ
る事を説明する必要が有るので説明がヤヤコシク成る事を
嫌ったと推測）】と高速化の為に【「while(--k>=0)】と
ｗｈｉｌｅループ使用しています！そして外側ループ中身
と記載した様に「for(i=step;--i>=0;){*p++=d;}」と
ｆｏｒループで同じ様にループ条件「--i>=0」を使って
高速に内側ループ中身「*p++=d;」とパターンをループで
「step」の数分、書き込みます！更に外側ループ中身では
「d+=step;if(d>d255){d=d255;}」で次に書き込む
データを算出し、セットします！但し、
分岐条件「d>d255」でデータが「255」を越えたら上限と
してその内側に補正します！
「while(p<=pend){*p++=d;}」は、ｗｈｉｌｅループ使用で
バッファー最後までパターンとしてデータを書き込みます！
「return(END_STI);」は、正常終了を返し関数終了！
（Ｅ）関数「Make9Lut()」の【使用例】
★注意★
使用例は、別の解説エッセイ『ＬＵＴ使用例』で別途説明す
る事に方針変換しました！使用例発表まで乞うご期待と記載
して置きます！
（４－１４－３５）関数「int MakeLut(BYTE lut[],int k,
int *arg,int l,int size){・・・｝」の説明
/************************************************************************/
/***** ＬＵＴデータの作成 ：実行部*****/
/***** 返し値：エラーチェックの値（END_STI,STI_FLG） *****/
/************************************************************************/
int CopyClear::MakeLut(
BYTE lut[], // 作成するＬＵＴ
int k, // 作成メニュー
int *arg, // 引数へのポインタ
int l, // 上記の組の数
int size // ＬＵＴの大きさ
){
int m; // Pattern書込始点Ix
int n; // Pattern書込終点Ix
int d; // パターン書込データ
int flg; // エラーフラッグ
switch( k ){ // 作成メニューが
case 0: // ０：増パターン加作成
case 1: // １：減少パターン作成
m = *arg++; // 始点Ixをセット
n = *arg++; // 終点Ixをセット
d = *arg; // 初期値データ をセット
m = ( m < 0 ) ? 0 : m; // 始点省略時：LUT始点
n = ( n < 0 ) ? size - 1 : n; // 終点省略時：LUT終点
if( n >= size ){ // 終点が範囲外なら
return( STI_FLG ); // 引数検査違反を返す
} //
if( k == 0 ){ // 増加なら
d = ( d < 0 ) ? 0 : d; // データ省略時：０
return( Make0Lut( lut, m, n, d ) ); // そのPatternを作成する
}else{ // 減少なら
d = ( d < 0 ) ? 255 : d; // データ省略時：２５５
return( Make1Lut( lut, m, n, d ) ); // そのパターンを作成
} //
case 2: // ２：２値Pattern作成
flg = STI_FLG; // エラーフラグ初期化
while( ( l -= 3 ) >= 0 ){ // 組数(3)だけ以下を繰返
m = *arg++; // 始点Ixをセット
n = *arg++; // 終点Ixをセット
d = *arg++; // 書き込みDataをセット
if( n >= size ){ // 終点が範囲外なら
return( STI_FLG ); // 引数検査違反を返す
} //
flg = Make2Lut( lut, m, n, d ); // ２値Patternを作成する
if( flg != END_STI ){ // 正常終了していなけれ
break; // 抜ける
} //
} //
return( flg ); // フラグを返す
case 3: // ３：任意直線
case 4: // ４：任意曲線
return( make_lut_xy( lut, k, arg, l, // 直線／曲線Pattern作成
size ) ); //
case 5: // ５：Γ／ｌｏｇ選択
m = *arg++; // パターン選択値セット
n = *arg; // 反転ｓｗをセット
return( Make5Lut( lut, m, n ) ); // Γ／ｌｏｇを選択する
case 6: // ６：疑似カラー
m = *arg++; // パターン選択値セット
n = *arg; // 色選択子をセット
return( Make6Lut( lut, m, n ) ); // 疑似ColPattern作成
case 7: // ７：ビットスライス
m = *arg++; // ビット位置 0..7
n = *arg; // 出力データ 1..255
return( Make7Lut( lut, m, n ) ); // BitSlicePattern作成
case 8: // ８：任意Γ選択
m = *arg++; // Γ係数セット
n = *arg; // 反転ｓｗをセット
return( Make8Lut( lut, m, n ) ); // 任意Γパターンを作成
case 9: // ８：任意Γ選択
m = *arg++; // Γ係数セット
return( Make9Lut( lut, m ) ); // 階調圧縮パターン作成
default: // 上記外なら
return( STI_FLG ); // 引数検査違反を返す
} //
}☆備考☆この関数はファイル「CopyClear040.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「MakeLut()」の【関数名】説明
「Make」は、作成するで
「Lut」は、勿論、ＬＵＴ変換用のＬＵＴです！
ココでは、「Make○○Lut」と枝番号○○で機能分けした
関数をサブルーチン関数として呼び出すとかでパターン発生
の親関数です！★注意★サブルーチン関数も「public:」属性
を付けていますので場合に依り、使用時に使い分けて下さ
い！
（Ｂ）関数「int MakeLut()」の【返値】説明
この関数内で明示的に検査しているのは、
仮引数「int k,」が、関数の選択肢として枝番号の
範囲「0..9」に成って居るか否かでエラーなら、
エラーコード「STI_FLG」を辺値とし関数終了！
最後まで実行時は、呼び出した枝番号のサブルーチン関数
の値を返します！
（Ｃ）関数「MakeLut()」の【仮引数】説明
int CopyClear::MakeLut(
BYTE lut[], // 作成するＬＵＴ
int k, // 作成メニュー
int *arg, // 引数へのポインタ
int l, // 上記の組の数
int size // ＬＵＴの大きさ
){「BYTE lut[],」はＬＵＴを一次元配列として使用！
「int k」は、枝番号「０．．９」です！
「int *arg,」は、枝番号のサブルーチン関数へパラメータ
を渡す為のポインタ！
「int l,」は、枝番号のサブルーチン関数へパラメータの
個数！★注意★「int arg,int l,」は、Ｃ言語処理系の
「int main(int argc,char*argv)」の「char*argv」が、
文字列へのポインタですが、ココでは数値の列に成ったと
考えて下さい！
「int size」は、ＬＵＴサイズ！
（Ｄ）関数「MakeLut()」の【アルゴリズム】説明
){
int m; // Pattern書込始点Ix
int n; // Pattern書込終点Ix
int d; // パターン書込データ
int flg; // エラーフラッグ
switch( k ){ // 作成メニューが
case 0: // ０：増パターン加作成
case 1: // １：減少パターン作成
m = *arg++; // 始点Ixをセット
n = *arg++; // 終点Ixをセット
d = *arg; // 初期値データ をセット
m = ( m < 0 ) ? 0 : m; // 始点省略時：LUT始点
n = ( n < 0 ) ? size - 1 : n; // 終点省略時：LUT終点
if( n >= size ){ // 終点が範囲外なら
return( STI_FLG ); // 引数検査違反を返す
} //
if( k == 0 ){ // 増加なら
d = ( d < 0 ) ? 0 : d; // データ省略時：０
return( Make0Lut( lut, m, n, d ) ); // そのPatternを作成する
}else{ // 減少なら
d = ( d < 0 ) ? 255 : d; // データ省略時：２５５
return( Make1Lut( lut, m, n, d ) ); // そのパターンを作成
} //
case 2: // ２：２値Pattern作成
flg = STI_FLG; // エラーフラグ初期化
while( ( l -= 3 ) >= 0 ){ // 組数(3)だけ以下を繰返
m = *arg++; // 始点Ixをセット
n = *arg++; // 終点Ixをセット
d = *arg++; // 書き込みDataをセット
if( n >= size ){ // 終点が範囲外なら
return( STI_FLG ); // 引数検査違反を返す
} //
flg = Make2Lut( lut, m, n, d ); // ２値Patternを作成する
if( flg != END_STI ){ // 正常終了していなけれ
break; // 抜ける
} //
} //
return( flg ); // フラグを返す
case 3: // ３：任意直線
case 4: // ４：任意曲線
return( make_lut_xy( lut, k, arg, l, // 直線／曲線Pattern作成
size ) ); //
case 5: // ５：Γ／ｌｏｇ選択
m = *arg++; // パターン選択値セット
n = *arg; // 反転ｓｗをセット
return( Make5Lut( lut, m, n ) ); // Γ／ｌｏｇを選択する
case 6: // ６：疑似カラー
m = *arg++; // パターン選択値セット
n = *arg; // 色選択子をセット
return( Make6Lut( lut, m, n ) ); // 疑似ColPattern作成
case 7: // ７：ビットスライス
m = *arg++; // ビット位置 0..7
n = *arg; // 出力データ 1..255
return( Make7Lut( lut, m, n ) ); // BitSlicePattern作成
case 8: // ８：任意Γ選択
m = *arg++; // Γ係数セット
n = *arg; // 反転ｓｗをセット
return( Make8Lut( lut, m, n ) ); // 任意Γパターンを作成
case 9: // ８：任意Γ選択
m = *arg++; // Γ係数セット
return( Make9Lut( lut, m ) ); // 階調圧縮パターン作成
default: // 上記外なら
return( STI_FLG ); // 引数検査違反を返す
} //
}（Ｄ－１）ローカル変数
){
int m; // Pattern書込始点Ix
int n; // Pattern書込終点Ix
int d; // パターン書込データ
int flg; // エラーフラッグ「int m;」は、パターン書き込み始点
「int n;」は、パターン書き込み終点
「int d;」は、パターン書き込みデータ
「int flg;」は、エラーコード一時置き場
（Ｄ－２）アルゴリズムコード
switch( k ){ // 作成メニューが
case 0: // ０：増パターン加作成
case 1: // １：減少パターン作成
m = *arg++; // 始点Ixをセット
n = *arg++; // 終点Ixをセット
d = *arg; // 初期値データ をセット
m = ( m < 0 ) ? 0 : m; // 始点省略時：LUT始点
n = ( n < 0 ) ? size - 1 : n; // 終点省略時：LUT終点
if( n >= size ){ // 終点が範囲外なら
return( STI_FLG ); // 引数検査違反を返す
} //
if( k == 0 ){ // 増加なら
d = ( d < 0 ) ? 0 : d; // データ省略時：０
return( Make0Lut( lut, m, n, d ) ); // そのPatternを作成する
}else{ // 減少なら
d = ( d < 0 ) ? 255 : d; // データ省略時：２５５
return( Make1Lut( lut, m, n, d ) ); // そのパターンを作成
} //
case 2: // ２：２値Pattern作成
flg = STI_FLG; // エラーフラグ初期化
while( ( l -= 3 ) >= 0 ){ // 組数(3)だけ以下を繰返
m = *arg++; // 始点Ixをセット
n = *arg++; // 終点Ixをセット
d = *arg++; // 書き込みDataをセット
if( n >= size ){ // 終点が範囲外なら
return( STI_FLG ); // 引数検査違反を返す
} //
flg = Make2Lut( lut, m, n, d ); // ２値Patternを作成する
if( flg != END_STI ){ // 正常終了していなけれ
break; // 抜ける
} //
} //
return( flg ); // フラグを返す
case 3: // ３：任意直線
case 4: // ４：任意曲線
return( make_lut_xy( lut, k, arg, l, // 直線／曲線Pattern作成
size ) ); //
case 5: // ５：Γ／ｌｏｇ選択
m = *arg++; // パターン選択値セット
n = *arg; // 反転ｓｗをセット
return( Make5Lut( lut, m, n ) ); // Γ／ｌｏｇを選択する
case 6: // ６：疑似カラー
m = *arg++; // パターン選択値セット
n = *arg; // 色選択子をセット
return( Make6Lut( lut, m, n ) ); // 疑似ColPattern作成
case 7: // ７：ビットスライス
m = *arg++; // ビット位置 0..7
n = *arg; // 出力データ 1..255
return( Make7Lut( lut, m, n ) ); // BitSlicePattern作成
case 8: // ８：任意Γ選択
m = *arg++; // Γ係数セット
n = *arg; // 反転ｓｗをセット
return( Make8Lut( lut, m, n ) ); // 任意Γパターンを作成
case 9: // ８：任意Γ選択
m = *arg++; // Γ係数セット
return( Make9Lut( lut, m ) ); // 階調圧縮パターン作成
default: // 上記外なら
return( STI_FLG ); // 引数検査違反を返す
} //
}「switch(k){・・ｃａｓｅ選択肢群・・
default:return(STI_FLG);}」は、ｓｗｉｔｃｈ構文での
多分岐選択し、選択肢「k」が、各ｃａｓｅラベルに一致し
無ければ、「return(STI_FLG);」でエラー
コード「STI_FLG」を返し、関数終了！
ｃａｓｅ選択肢群から、「case0:case1:」の場合、
「m=*arg++;n=*arg++;d=*arg;」でサブルーチン関数の
「int Make0Lut(BYTE lut[],int m,int n,int d)」・
「int Make1Lut(BYTE lut[],int m,int n,int d)」の
仮引数「int m,int n,int d」に相当するパラメータを
コノ関数の仮引数「int *arg,」から取り出します！
「m=(m<0)?0:m;n=(n<0)?size-1:n;if(n>=size){
return(STI_FLG);}」で取り出したパラメータを絶対値化
とか、設定値を負数が省略時設定に成るとか、パラメータの
エラーチェックとし不都合なら、エラーコード「STI_FLG」
を返し、関数終了！
「if(k==0){d=(d<0)?0:d;return(Make0Lut(lut,m,n,d));
}else{d=(d<0)?255:d;return(Make1Lut(lut,m,n,d));}」
は、条件「k==0」詰り、インクリメントパターンの場合、
初期値「d」が負数なら「0」に補正し、サブルーチン関数
として「return(Make0Lut(lut,m,n,d));」と処理し、その
関数値を関数の値として関数終了！そしてデクリメント
パターンの場合、初期値「d」が２５５を越える値なら
「255」に補正し、サブルーチン関数として
「return(Make1Lut(lut,m,n,d));」と処理し、
その関数返値を関数の値として関数終了！
「case2:」の場合、「flg=STI_FLG;」で初期値を入れて
置き、「while((l-=3)>=0){・・ループ中身・・}」で
引数のパラメタ数「l」を「(l-=3)>=0」と３づつ減算する
のは、「m=*arg++;n=*arg++;d=*arg++;」と
「int Make2Lut(BYTE lut[],int m,int n,int d)」の
仮引数「int m,int n,int d」に相当するパラメータを
コノ関数の仮引数「int *arg,」から取り出す為に３づつ
減算！そしてループ中身は、「m=*arg++;n=*arg++;
d=*arg++;」で簡単に先ほど説明した様にパラメータ取り
出し、「if(n>=size){return(STI_FLG);}」で終点が
ＬＵＴサイズを越えたらエラーとし、関数終了！
「flg=Make2Lut(lut,m,n,d);」でサブルーチン関数「
Make2Lut(lut,m,n,d);」で処理しと複数回パラメータが
３組み存在する場合実行し、
「if(flg!=END_STI){break;}」でサブルーチン関数が、
エラー時にｓｗｉｔｃｈ構文から抜けます！そして
ｗｈｉｌｅループが終了したら、「return(flg);」で
サブルーチン関数の関数返値を関数の値として関数終了！
「case3:case4:」の場合、「return(make_lut_xy(
lut,k,arg,l,size));」でサブルーチン
関数「make_lut_xy(lut,k,arg,l,size)」で複数ポイントを
結ぶ、折れ線グラフ的にパターン書き込み！
「case5:」の場合、「m=*arg++;n=*arg;
return(Make5Lut(lut,m,n));」とサブルーチン関数
「Make5Lut()」に必要なパラメータ「m,n」を
「m=*arg++;n=*arg;」で取り出し、サブルーチン関数
「Make6Lut()」で処理し、この関数の辺値を関数自体の
辺値として返し関数終了！
「case6:」の場合、「m=*arg++;n=*arg;
return(Make6Lut(lut,m,n));」とサブルーチン関数
「Make6Lut()」に必要なパラメータ「m,n」を
「m=*arg++;n=*arg;」で取り出し、サブルーチン関数
「Make6Lut()」で処理し、この関数の辺値を関数自体の
辺値として返し関数終了！
「case7:」の場合、「m=*arg++;n=*arg;
return(Make7Lut(lut,m,n));」とサブルーチン関数
「Make7Lut()」に必要なパラメータ「m,n」を
「m=*arg++;n=*arg;」で取り出し、サブルーチン関数
「Make7Lut()」で処理し、この関数の辺値を関数自体の
辺値として返し関数終了！
「case8:」の場合、「m=*arg++;n=*arg;
return(Make8Lut(lut,m,n));」とサブルーチン関数
「Make8Lut()」に必要なパラメータ「m,n」を
「m=*arg++;n=*arg;」で取り出し、サブルーチン関数
「Make8Lut()」で処理し、この関数の辺値を関数自体の
辺値として返し関数終了！
「case9:」の場合、「m=*arg++;
return(Make9Lut(lut,m));」とサブルーチン関数
「Make9Lut()」に必要なパラメータ「m」を
「m=*arg++;」で取り出し、サブルーチン関数
「Make9Lut()」で処理し、この関数の辺値を関数自体の
辺値として返し関数終了！
「return(STI_FLG);」は、サブルーチン関数で正常終了し
無かったとしてエラーコード「STI_FLG」を返し関数終了！
（Ｅ）関数「MakeLut()」の【備考】
細かい、パターン書き込みの解説は、各サブルーチン関数
の解説を参考にして下さい！【例文】等は、各サブルーチン
関数で説明しています！但し、サブルーチン関数「
make_lut_xy(lut,k,arg,l,size)」は、「private:」属性
を付けていますので解説は「private:」属性関数を
後回しにしますので暫く、お待ちください！
（４－１４－３６）関数「int MakeLutToArray(TypeArray* lut,int k,int *arg,int l){・・・｝」の説明
/************************************************************************/
/***** ＬＵＴデータの作成 *****/
/***** 返し値：エラーチェックの値（END_STI,STI_FLG） *****/
/************************************************************************/
int CopyClear::MakeLutToArray(
TypeArray *lut, // 作成するＬＵＴ
int k, // 作成メニュー
int *arg, // 引数へのポインタ
int l // 上記の組の数
){
BYTE buf[ 65536 ]; // ＬＵＴPatternBuf
BYTE *lutptr; // 上記の実ポインタ
int size; // ＬＵＴのサイズ
size = lut->h; // LUTSizeを取り出し
if( size > 65536 ){ // 65536を超えたら
size = 65536; // 65536に補正する
} //
if( lut->w == 1 ){ // １Byteサイズなら
lutptr = (BYTE*)lut->adr; // LUTのAdrを取出し
}else{ // その他なら
lutptr = buf; // Bufferをセットし
} //
if( MakeLut( lutptr, k, arg, l, size ) // LUTPatternを作成
!= END_STI ){ // 作成に失敗したら
return( STI_FLG ); // 不正を返す
} //
return( MoveByteArray( lutptr, lut, size ) ); // 配列array型へ格納
}☆備考☆この関数はファイル「CopyClear040.cpp」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「MakeLutToArray()」の【関数名】説明
「Make」は、作成するで
「Lut」は、勿論、ＬＵＴ変換用のＬＵＴです！
「To」は、「○○から××」と「から」の意味です！
「Array」は、このライブラリで画像メモリを定義する
クラス「TypeArray」を意味します！
ココでは、「Make○○Lut」と枝番号○○で機能分けした
関数をサブルーチン関数として呼び出すとかでパターン発生
の親関数です！と関数「MakeLut()」に解説して居ましたが
この関数は、コノ関数「MakeLut()」をサブルーチン関数と
して呼び出す関数で関数「MakeLut()」は、
「BYTE lut[],」はＬＵＴを一次元配列として使用しますが
この関数は、クラス「TypeArray」で定義した一次元配列に
値を格納する事で行う事が異なります！
★注意★何故、この様な関数が存在するかと言うと、
ＡＤＳ社画像処理装置に簡易コマンド言語「ＰＩＰＬ」で
使用する為に開発当時は、構造体「TypeArray」でコマンド
の型で使用出来る様にあうる仕掛けで必要なだけでＣ言語で
ライブラリ関数を使用する人には知らなくても良い話ですが
私としては、画像処理言語「ＰＩＰＬ」をリニューアル作成
する心算ですので残して置いたのです！
（Ｂ）関数「int MakeLutToArray()」の【返値】説明
この関数の辺値は呼び出した関数の辺値及び、呼び出した
関数がエラーを起こしたら「return(STI_FLG);」と
エラーコードを返し終了します！
（Ｃ）関数「MakeLutToArray()」の【仮引数】説明
int CopyClear::MakeLutToArray(
TypeArray *lut, // 作成するＬＵＴ
int k, // 作成メニュー
int *arg, // 引数へのポインタ
int l // 上記の組の数
){「TypeArray* lut,」は、クラス「TypeArray」で定義
した一次元配列にＬＵＴパターンを格納する為
「int k」は、枝番号「０．．９」です！
「int *arg,」は、枝番号のサブルーチン関数へパラメータ
を渡す為のポインタ！
「int l,」は、枝番号のサブルーチン関数へパラメータの
個数！★注意★「int *arg,int l,」は、Ｃ言語処理系の
「int main(int argc,char*argv)」の「char*argv」が、
文字列へのポインタですが、ココでは数値の列に成ったと
考えて下さい！
（Ｄ）関数「MakeLutToArray()」の【アルゴリズム】説明
){
BYTE buf[ 65536 ]; // ＬＵＴPatternBuf
BYTE *lutptr; // 上記の実ポインタ
int size; // ＬＵＴのサイズ
size = lut->h; // LUTSizeを取り出し
if( size > 65536 ){ // 65536を超えたら
size = 65536; // 65536に補正する
} //
if( lut->w == 1 ){ // １Byteサイズなら
lutptr = (BYTE*)lut->adr; // LUTのAdrを取出し
}else{ // その他なら
lutptr = buf; // Bufferをセットし
} //
if( MakeLut( lutptr, k, arg, l, size ) // LUTPatternを作成
!= END_STI ){ // 作成に失敗したら
return( STI_FLG ); // 不正を返す
} //
return( MoveByteArray( lutptr, lut, size ) ); // 配列array型へ格納
}（Ｄ－１）ローカル変数
){
BYTE buf[ 65536 ]; // ＬＵＴPatternBuf
BYTE *lutptr; // 上記の実ポインタ
int size; // ＬＵＴのサイズ「BYTE buf[65536];」は、ローカルパターンバッファー！
「BYTE *lutptr;」は、最終的に格納する仮引数「
TypeArray lut,」の実格納ポインタです！
「int size;」は、ＬＵＴの格納サイズです！
（Ｄ－２）アルゴリズムコード
size = lut->h; // LUTSizeを取り出し
if( size > 65536 ){ // 65536を超えたら
size = 65536; // 65536に補正する
} //
if( lut->w == 1 ){ // １Byteサイズなら
lutptr = (BYTE*)lut->adr; // LUTのAdrを取出し
}else{ // その他なら
lutptr = buf; // Bufferをセットし
} //
if( MakeLut( lutptr, k, arg, l, size ) // LUTPatternを作成
!= END_STI ){ // 作成に失敗したら
return( STI_FLG ); // 不正を返す
} //
return( MoveByteArray( lutptr, lut, size ) ); // 配列array型へ格納
}「size=lut->h;」は、仮引数「TypeArray* lut,」の格納
サイズを変数「size」にセット！
「if(size>65536){size=65536;}」は、サイズを最大値で
有る「65536」以内に補正！
「if(lut->w==1){lutptr=(BYTE )lut->adr;}else{
lutptr=buf;}」は、仮引数「TypeArray lut,」のデータ
単位が１バイト単位ならば、「lutptr=(BYTE *)lut->adr;」
と実格納ポインタをセット、異なる場合、「lutptr=buf;」
とローカルバッファーにセット！
「if(MakeLut(lutptr,k,arg,l,size)!=END_STI){
return(STI_FLG);}」は、分岐の条件内で
「MakeLut(lutptr,k,arg,l,size」とサブルーチン関数「
MakeLut()」を実行し、その関数辺値が正常終了で無ければ
「return(STI_FLG);」とエラーコード「STI_FLG」を返し、
関数終了！
「return(MoveBYTE Array(lutptr,lut,size));」は、
サブルーチン関数「MoveBYTE Array()」でパターン書き込み
コノ関数の辺値を関数の辺値として関数終了！
（Ｅ）関数「MakeLutToArray()」の【備考】
細かい、パターン書き込みの解説は、各サブルーチン関数
の解説を参考にして下さい！【例文】等は、各サブルーチン
関数で説明しています！
★注意★何故、この様な関数が存在するかと言うと、
ＡＤＳ社画像処理装置に簡易コマンド言語「ＰＩＰＬ」で
使用する為に開発当時は、構造体「TypeArray」でコマンド
の型で使用出来る様に合う仕掛けで必要なだけでＣ言語で
ライブラリ関数を使用する人には知らなくても良い話ですが
私としては、画像処理言語「ＰＩＰＬ」をリニューアル作成
する心算ですので残して置いたのです！
次から、関数「MakePattern()」とＬＵＴでは無く、画像の
パターンを作成する関数の解説に成ります！大分機能が、
変りますし、サイズも大きく成り、追記も正直、遣り難く
成ったので、今回の追記でこの講義は、
解説『解説クラスＣｏｐｙＣｌｅａｒ（１４）』を終わり
ます！引き続き関数「MakePattern()」以降を
新規解説『解説クラスＣｏｐｙＣｌｅａｒ（１５）』として
近々、始めますので宜しく、御贔屓の程、お願いします！