解説クラスＴｙｐｅＡｒｒａｙ
解説クラスＴｙｐｅＡｒｒａｙ
２０２４年１月２９初講（初稿）
先に、解説『画像メモリ概要』で紹介した！
画像を扱う基本としての「画像型」としてクラス
【class TypeArray{}】の解説を今回は、行います！
１．ヘッダーファイル
比較的、小サイズのヘッダーファイルなので全てＮｏｔｅの
「code」機能で以下の様に示した後で解説して行きます！
// TypeArray.h: TypeArray クラスのインターフェイス
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_TYPEARRAY_H__56FCB107_5EA8_4B0E_8163_AA17B7C4E050__INCLUDED_)
#define AFX_TYPEARRAY_H__56FCB107_5EA8_4B0E_8163_AA17B7C4E050__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "ImageFuncDef.h" // 画像処理関数の定義部
/************************************************************************/
/***** 画像および１次元配列、２次元配列の記述するためのクラス *****/
/***** 画像は２次元配列と同等 *****/
/************************************************************************/
class TypeArray // クラス名「TypeArray」
{
public:
TypeArray(); // コンストラクタ
virtual ~TypeArray(); // デストラクタ
int Malloc( int w1, int h1, int v1 ); // 総合型配列メモリ確保＆定義
int MallocByte( int h1, int v1 ); // BYTE型配列メモリ確保＆定義
int MallocShort( int h1, int v1 ); // short型配列メモリ確保＆定義
int MallocInt( int h1, int v1 ); // int型配列メモリ確保＆定義
int MallocFloat( int h1, int v1 ); // float型配列メモリ確保＆定義
int MallocDouble( int h1, int v1 ); // double型配列メモリ確保＆定義
int SetByte( int a, int h1, int v1 ); // BYTE型配列定義
int SetShort( int a, int h1, int v1 ); // short型配列定義
int SetInt( int a, int h1, int v1 ); // int型配列定義
int SetFloat( int a, int h1, int v1 ); // float型配列定義
int SetDouble( int a, int h1, int v1 ); // double型配列定義
int SetByte( void* p, int h1, int v1 ); // BYTE型配列定義
int SetShort( void* p, int h1, int v1 ); // short型配列定義
int SetInt( void* p, int h1, int v1 ); // int型配列定義
int SetFloat( void* p, int h1, int v1 ); // float型配列定義
int SetDouble( void* p, int h1, int v1 ); // double型配列定義
int subset( // 部分配列の定義
TypeArray* orgPtr, // 元へのポインタ
int x, int y, // 始点ｘｙ座標
int h1, int v1 ); // 水平・垂直幅
int subsetAdjust( // 部分配列の定義：幅自動調整
TypeArray* orgPtr, // 元へのポインタ
int x, int y, // 始点ｘｙ座標
int h1, int v1 ); // 水平・垂直幅
int subsetBMP( // 部分配列の定義：表示用ＢＭＰ専用
TypeArray* orgPtr, // 元へのポインタ
int x, int y, // 始点ｘｙ座標：カラー画素単位
int h1, int v1 ); // 水平・垂直幅：カラー画素単位
int subsetRev( // 部分配列の定義：表示用ＢＭＰ専用
TypeArray* orgPtr, // 元へのポインタ
int x, int y, // 始点ｘｙ座標：個別画素単位
int h1, int v1 ); // 水平・垂直幅：個別画素単位
int get( int x, int y ); // 画素取り出し
double getReal( int x, int y ); // 画素取り出し：実数
void put( int x, int y, int d ); // 画素書き込み
void put( int x, int y, double d ); // 画素書き込み
int getDataInt( int x, int y ); // データ取りだし：４バイト整数
int getDataShort( int x, int y ); // データ取りだし：２バイト整数
void putDataInt( int x, int y, int d ); // データ書き込み：４バイト整数
void putDataShort( int x, int y, int d ); // データ書き込み：２バイト整数
public: // 構造体の内部変数（画像サイズ＆画素型）
int adr; // アドレス
int h; // 水平方向大きさ（実範囲）
int v; // 垂直大きさ
int inc; // 水平方向大きさ(垂直増加用)0:１次
char w; // 処理幅（1/2/4BYTE,101:単精度,102:倍精度）
public: // inline 関数
inline int maxX(void){ return( h - 1 ); } // 最大Ｘ座標
inline int maxY(void){ return( v - 1 ); } // 最大Ｙ座標
inline int size(void){ return( h * v ); } // 画素数
inline int sizePix(void) // BYTE換算単位サイズ
{ //
if( w == 101 ){ // 単精度なら
return( 4 ); // ４を答えとする
}else if( w == 102 ){ // 倍精度なら
return( 8 ); // ８を答えとする
}else{ // 1/2/4BYTEなら
return( w ); // 左記で算出
} //
} //
inline int sizeMem(void){ // メモリサイズ
return( size() * sizePix() ); } // ＝画素数×単位サイズ
inline int sizeInc(void){ // BYTE換算増加幅
return( inc * sizePix() ); } // ＝増加幅×単位サイズ
inline void freeMem(void) // メモリ解放
{ //
if( adr != 0 ){ // メモリ取得済みなら
free( (void*)adr ); // メモリを解放し
adr = 0; // アドレスを初期化
} //
}
inline int check( int x, int y ){ // 検査：全般
if( adr <= 0 || x < 0 || x >= h // アドレスや
|| y < 0 || y >= v ){ // 座標が不正なら、
return( STI_FLG ); // 不正を返す
} //
return( END_STI ); // 正常終了
}
inline int checkXY( int x, int y ){ // 検査：座標
if( x < 0 || x >= h || y < 0 || y >= v ){ // 座標が不正
return( STI_FLG ); // なら、不正を返す
} //
return( END_STI ); // 正常終了
}
inline int getByte( int x, int y ){ // 画素取り出し
return( *( (BYTE*)adr + x + y * inc ) ); } // BYTE単位
inline int getShort( int x, int y ){ // 画素取り出し
return( *( (short*)adr + x + y * inc ) ); } // short単位
inline int getInt( int x, int y ){ // 画素取り出し
return( *( (int*)adr + x + y * inc ) ); } // int単位
inline double getFloat( int x, int y ){ // 画素取り出し
return( *( (float*)adr + x + y * inc ) ); } // 単精度単位
inline double getDouble( int x, int y ){ // 画素取り出し
return( *( (double*)adr + x + y * inc ) ); } // 倍精度単位
inline void putByte( int x, int y, int d ){ // 画素書き込み
*( (BYTE*)adr + x + y * inc ) = d; } // BYTE単位
inline void putShort( int x, int y, int d ){ // 画素書き込み
*( (short*)adr + x + y * inc ) = d; } // short単位
inline void putInt( int x, int y, int d ){ // 画素書き込み
*( (int*)adr + x + y * inc ) = d; } // int単位
inline void putFloat( int x, int y, double d ){ // 画素書き込み
*( (float*)adr + x + y * inc ) = (float)d; } // 単精度単位
inline void putDouble( int x, int y, double d ){ // 画素書き込み
*( (double*)adr + x + y * inc ) = d; } // 倍精度単位
inline BYTE* getPtrByte( int x, int y ){ // 画素アクセスポインタ取出
return( (BYTE*)adr + x + y * inc ); } // BYTE単位
inline short* getPtrShort( int x, int y ){ // 画素アクセスポインタ取出
return( (short*)adr + x + y * inc ); } // short単位
inline int* getPtrInt( int x, int y ){ // 画素アクセスポインタ取出
return( (int*)adr + x + y * inc ); } // int単位
inline float* getPtrFloat( int x, int y ){ // 画素アクセスポインタ取出
return( (float*)adr + x + y * inc ); } // 単精度単位
inline double* getPtrDouble( int x, int y ){ // 画素アクセスポインタ取出
return( (double*)adr + x + y * inc ); } // 倍精度単位
};
#endif // !defined(AFX_TYPEARRAY_H__56FCB107_5EA8_4B0E_8163_AA17B7C4E050__INCLUDED_)
（１）「#include」等、「#」構文を使用した先頭部分
「#if !defined(AFX_TYPEARRAY_H__・・・」は、
WindowsＸＰ上でＶＳ（ヴィジュアルスタジオ、
以下「（）」内は省略しＶＳと表記）が自動生成した、
「#include」を多重に動作させて無駄に定義をコンパイラ
システムに読み込ませ無い工夫としての
「#if !defined（）・・・#endif」構文です！
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
と３行もＶＳが自動生成したものでＶＳに取っての都合と
思って居るから、Windows以外のシステムをお使いの人は、
無くても良い物と思います！！
#include "ImageFuncDef.h" // 画像処理関数の定義部
この「#include」で「#define」定義した数値定数、及び、
この単純な型名の定義が記述された定義ファイルを
インクルードする事を示します！
これらは、解説『エラーコード等各種単純定義』で説明して
居ます！
（２）クラス「TypeArray構文で定義」した！メソッド（
メンバー関数）の定義概要
（２－１）コンストラクタ／デストラクタ
TypeArray(); // コンストラクタ
virtual ~TypeArray(); // デストラクタ上記の様にクラス定義お馴染みの記載です！
//////////////////////////////////////////////////////////////////////
// 構築/消滅
//////////////////////////////////////////////////////////////////////
TypeArray::TypeArray()
{
adr = 0; // 初期値＝無効
}
TypeArray::~TypeArray()
{
}コンストラクタに関しては、上記の様にメンバー変数
「int adr;」を初期化「０クリア」しているだけです！
（２－２）メモリ確保
画像メモリとしてコンピュータシステムから動的に領域を
確保する関数です！
コレを使用する事で画像処理する対象の画像メモリが手に
入ります！
int Malloc( int w1, int h1, int v1 ); // 総合型配列メモリ確保＆定義
int MallocByte( int h1, int v1 ); // BYTE型配列メモリ確保＆定義
int MallocShort( int h1, int v1 ); // short型配列メモリ確保＆定義
int MallocInt( int h1, int v1 ); // int型配列メモリ確保＆定義
int MallocFloat( int h1, int v1 ); // float型配列メモリ確保＆定義
int MallocDouble( int h1, int v1 ); // double型配列メモリ確保＆定義
これから、個別に解説していきます！先ず、メソッド（
メンバー関数）本体を「TypeArray.cpp」から抜き出すと
/*page*/
/************************************************************************/
/***** ユーザ定義配列メモリ確保＆定義：総合 *****/
/************************************************************************/
int TypeArray::Malloc(
int w1, // 単位
int h1, // 水平幅
int v1 // 垂直幅
){
switch( w1 ){ // 単位が
case 1: // BYTEなら
return( MallocByte( h1, v1 ) ); // BYTEメモリ確保
case 2: // 2BYTEなら
return( MallocShort( h1, v1 ) ); // short型メモリ確保
case 4: // 4BYTEなら
return( MallocInt( h1, v1 ) ); // int型メモリ確保
case 101: // 単精度実数なら
return( MallocFloat( h1, v1 ) ); // 単精度型メモリ確保
case 102: // 倍精度実数なら
return( MallocDouble( h1, v1 ) ); // 倍精度型メモリ確保
default: // 上記以外ならば
return( STI_ARY_5 ); // 左記を返す
} //
}
/*page*/
/************************************************************************/
/***** ユーザ定義配列メモリ確保＆定義：ＢＹＴＥ単位 *****/
/************************************************************************/
int TypeArray::MallocByte(
int h1, // 水平幅
int v1 // 垂直幅
){
if( h1 <= 0 || v1 <= 0 ){ // 幅が不正なら
return( STI_FLG ); // 不正を返す
} //
adr = (int)malloc( sizeof(BYTE) * h1 * v1 ); // メモリを確保
if( adr == 0 ){ // 失敗時は
return( STI_MEM ); // 不正を返す
} //
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 1; // 処理単位=ＢＹＴＥ
return( END_STI ); // 正常終了
}
/************************************************************************/
/***** ユーザ定義配列メモリ確保＆定義：ｓｈｏｒｔ単位 *****/
/************************************************************************/
int TypeArray::MallocShort(
int h1, // 水平幅
int v1 // 垂直幅
){
if( h1 <= 0 || v1 <= 0 ){ // 幅が不正なら
return( STI_FLG ); // 不正を返す
} //
adr = (int)malloc( sizeof(short) * h1 * v1 ); // メモリを確保
if( adr == 0 ){ // 失敗時は
return( STI_MEM ); // 不正を返す
} //
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 2; // 処理単位=２BYTE
return( END_STI ); // 正常終了
}
/************************************************************************/
/***** ユーザ定義配列メモリ確保＆定義：ｉｎｔ単位 *****/
/************************************************************************/
int TypeArray::MallocInt(
int h1, // 水平幅
int v1 // 垂直幅
){
if( h1 <= 0 || v1 <= 0 ){ // 幅が不正なら
return( STI_FLG ); // 不正を返す
} //
adr = (int)malloc( sizeof(int) * h1 * v1 ); // メモリを確保
if( adr == 0 ){ // 失敗時は
return( STI_MEM ); // 不正を返す
} //
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 4; // 処理単位=４BYTE
return( END_STI ); // 正常終了
}
/*page*/
/************************************************************************/
/***** ユーザ定義配列メモリ確保＆定義：単精度単位 *****/
/************************************************************************/
int TypeArray::MallocFloat(
int h1, // 水平幅
int v1 // 垂直幅
){
if( h1 <= 0 || v1 <= 0 ){ // 幅が不正なら
return( STI_FLG ); // 不正を返す
} //
adr = (int)malloc( sizeof(float) * h1 * v1 ); // メモリを確保
if( adr == 0 ){ // 失敗時は
return( STI_MEM ); // 不正を返す
} //
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 101; // 処理単位=単精度
return( END_STI ); // 正常終了
}
/************************************************************************/
/***** ユーザ定義配列メモリ確保＆定義：倍精度単位 *****/
/************************************************************************/
int TypeArray::MallocDouble(
int h1, // 水平幅
int v1 // 垂直幅
){
if( h1 <= 0 || v1 <= 0 ){ // 幅が不正なら
return( STI_FLG ); // 不正を返す
} //
adr = (int)malloc( sizeof(double) * h1 * v1 ); // メモリを確保
if( adr == 0 ){ // 失敗時は
return( STI_MEM ); // 不正を返す
} //
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 102; // 処理単位=倍精度
return( END_STI ); // 正常終了
}（２－２－１）関数「int Malloc(int w1, int h1, int v1);」
/*page*/
/************************************************************************/
/***** ユーザ定義配列メモリ確保＆定義：総合 *****/
/************************************************************************/
int TypeArray::Malloc(
int w1, // 単位
int h1, // 水平幅
int v1 // 垂直幅
){
switch( w1 ){ // 単位が
case 1: // BYTEなら
return( MallocByte( h1, v1 ) ); // BYTEメモリ確保
case 2: // 2BYTEなら
return( MallocShort( h1, v1 ) ); // short型メモリ確保
case 4: // 4BYTEなら
return( MallocInt( h1, v1 ) ); // int型メモリ確保
case 101: // 単精度実数なら
return( MallocFloat( h1, v1 ) ); // 単精度型メモリ確保
case 102: // 倍精度実数なら
return( MallocDouble( h1, v1 ) ); // 倍精度型メモリ確保
default: // 上記以外ならば
return( STI_ARY_5 ); // 左記を返す
} //
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－２－１－Ａ）関数名「Malloc()」
「M」は、メモリー詰り、画像メモリを示す略です！
「alloc」は、英単語「allocation」アロケーションの略で
割り当て、割付を意味します！
詰り、半導体メモリーを画像メモリに割り当てる事を意味
します！
（２－２－１－Ｂ）関数「Malloc();」の【仮引数】説明
int TypeArray::Malloc(
int w1, // 単位
int h1, // 水平幅
int v1 // 垂直幅
){「int w1,」は、画素のタイプ≪整数型ならば、１・２・４
とバイト数指定浮動小数点数型は、
１０１で単精度浮動小数点数型（４バイト）・
１０２で倍精度浮動小数点数型（８バイト）≫を指定しま
す！これ以外は、エラーとしてエラーコード≪
解説『エラーコード等各種単純定義』で説明≫として
「STI_ARY_5」＝「-1005 」を関数の値として返します！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
上図の様に解説『画像メモリ概要』で説明した！
水平幅・垂直幅に成ります！
（２－２－１－Ｃ）関数「Malloc();」の【アルゴリズム】説明
){
switch( w1 ){ // 単位が
case 1: // BYTEなら
return( MallocByte( h1, v1 ) ); // BYTEメモリ確保
case 2: // 2BYTEなら
return( MallocShort( h1, v1 ) ); // short型メモリ確保
case 4: // 4BYTEなら
return( MallocInt( h1, v1 ) ); // int型メモリ確保
case 101: // 単精度実数なら
return( MallocFloat( h1, v1 ) ); // 単精度型メモリ確保
case 102: // 倍精度実数なら
return( MallocDouble( h1, v1 ) ); // 倍精度型メモリ確保
default: // 上記以外ならば
return( STI_ARY_5 ); // 左記を返す
} //
}「ｓｗｉｔｃｈ」構文で「switch( w1 ){case 1:・・中身Ａ・・
case 2:・・中身Ｂ・・case 4:・・中身Ｃ・・
case 101:・・中身Ｄ・・case 102:・・中身Ｅ・・}」と仮引数「int w1」の値に対応する「ｃａｓｅラベル」
例えば、（w1==1）ならば、
「return(MallocByte(h1,v1));」を実行し中身が「return」
なので関数が終了します！
詰り、仮引数「int w1」の値≪画素のタイプを示す≫に
対応した以下に説明する「画素のタイプ」に対応する
メソッド（メンバー関数）を実行します！
最後の「default:」で仮引数「int w1」の値に対応して
ない場合は、エラーコード（STI_ARY_5）と
「配列情報：w の値が不正」を返します！
（２－２－２）関数「int MallocByte(int h1, int v1);」
先ず、メソッド（メンバー関数）本体を「TypeArray.cpp」
から抜き出すと
int TypeArray::MallocByte(
int h1, // 水平幅
int v1 // 垂直幅
){
if( h1 <= 0 || v1 <= 0 ){ // 幅が不正なら
return( STI_FLG ); // 不正を返す
} //
adr = (int)malloc( sizeof(BYTE) * h1 * v1 ); // メモリを確保
if( adr == 0 ){ // 失敗時は
return( STI_MEM ); // 不正を返す
} //
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 1; // 処理単位=ＢＹＴＥ
return( END_STI ); // 正常終了
}（２－２－２－Ａ）関数名「MallocByte」
「M」は、メモリー詰り、画像メモリを示す略です！
「alloc」は、英単語「allocation」アロケーションの略で
割り当て、割付を意味します！詰り、半導体メモリーを画像
メモリに割り当てる事を意味します！
「Byte」は、「BYTE型」＝「unsigned char」と１バイト
符号無し整数型を示します！
何故、「Byte」と記載したかは、「英大文字」を区切り
として使用し後を小文字にして区切った表記上の手法です！
（２－２－２－Ｂ）関数「MallocByte();」の【仮引数】説明
int TypeArray::MallocByte(
int h1, // 水平幅
int v1 // 垂直幅
){「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－２－２－Ｃ）関数「MallocByte();」の【アルゴリズム】説明
){
if( h1 <= 0 || v1 <= 0 ){ // 幅が不正なら
return( STI_FLG ); // 不正を返す
} //
adr = (int)malloc( sizeof(BYTE) * h1 * v1 ); // メモリを確保
if( adr == 0 ){ // 失敗時は
return( STI_MEM ); // 不正を返す
} //
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 1; // 処理単位=ＢＹＴＥ
return( END_STI ); // 正常終了
}「if(h1<=0||v1<=0){return(STI_FLG);}」は、
仮引数「int h1,int v1」をエラーチェック≪水平幅「h1」
も垂直幅「v1」も０より大きい値が必要で異なれば、関数の
値として「STI_FLG」⇒引数が不正を返し終了≫を行います！
「adr=(int)malloc(sizeof(BYTE)h1*v1);」は、Ｃ言語標準
関数の「void*malloc(size_t n);」と「メモリ・ブロックの
動的確保」関数です
「sizeof(BYTE)h1v1」で先ず、「sizeof(BYTE)」で
「BYTE型」のバイト数、「h1v1」で「水平幅×垂直幅」と
画像メモリとして必要なサイズを示し、
「sizeof(BYTE)h1*v1」で必要なバイト数を算出する事を
意味し、「malloc(sizeof(BYTE)h1*v1);」でシステムから
必要な画像メモリとして領域を取得する事を意味します！
そして「adr=・・・;」は、クラス「TypeArray」の画像始点
を示すメンバー変数「adr」に値をセットする事を示します！
「if(adr==0){return(STI_MEM);}」は、関数「malloc()」の
実行結果≪システムから領域を取得すれば、そのメモリーの
（void*）ポインタ、詰り半導体メモリーないしは
仮想メモリ空間のアドレスの値を返すが、「０」＝空ポイン
タが関数の値として帰って来たら、システムから領域を取得
出来無かった（恐らく、許される上限を越えた場合）≫⇒
「adr==0」の条件成立はエラーが発生したので関数の値と
して「STI_MEM」⇒「メモリ不足」をエラーコードとして
関数の値として返します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を
示します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を示し
ます！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示すメンバー変数「inc」に値をセットする事を
示します！
「w=1; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載
したメンバー変数」に整数型１バイト単位画素を示す
「w=1;」をセットします！
「return(END_STI);」は、正常に動作≪メモリ取得に成功≫
（２－２－３）関数「int MallocShort(int h1, int v1);」
先ず、メソッド（メンバー関数）本体を「TypeArray.cpp」
から抜き出すと
int TypeArray::MallocShort(
int h1, // 水平幅
int v1 // 垂直幅
){
if( h1 <= 0 || v1 <= 0 ){ // 幅が不正なら
return( STI_FLG ); // 不正を返す
} //
adr = (int)malloc( sizeof(short) * h1 * v1 ); // メモリを確保
if( adr == 0 ){ // 失敗時は
return( STI_MEM ); // 不正を返す
} //
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 2; // 処理単位=２BYTE
return( END_STI ); // 正常終了
}（２－２－３－Ａ）関数名「MallocShort」
「M」は、メモリー詰り、画像メモリを示す略です！
「alloc」は、英単語「allocation」アロケーションの略で
割り当て、割付を意味します！
詰り、半導体メモリーを画像メモリに割り当てる事を意味
します！
「Short」は、「Short型」２バイト符号有り整数型を示し
ます！
（２－２－３－Ｂ）関数「MallocShort();」の【仮引数】説明
int TypeArray::MallocShort(
int h1, // 水平幅
int v1 // 垂直幅
){「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－２－３－Ｃ）関数「MallocShort();」の【アルゴリズム】説明
){
if( h1 <= 0 || v1 <= 0 ){ // 幅が不正なら
return( STI_FLG ); // 不正を返す
} //
adr = (int)malloc( sizeof(short) * h1 * v1 ); // メモリを確保
if( adr == 0 ){ // 失敗時は
return( STI_MEM ); // 不正を返す
} //
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 2; // 処理単位=２BYTE
return( END_STI ); // 正常終了
}「if(h1<=0||v1<=0){return(STI_FLG);}」は、
仮引数「int h1,int v1」をエラーチェック≪水平幅「h1」
も垂直幅「v1」も０より大きい値が必要で異なれば、
関数の値として「STI_FLG」⇒引数が不正を返し終了≫を
行います！
「adr=(int)malloc(sizeof(Short)h1*v1);」は、Ｃ言語
標準関数の「voidmalloc(size_t n);」と「メモリ・
ブロックの動的確保」関数です！
「sizeof(Short)h1*v1」で先ず、「sizeof(Short)」で
「Short型」のバイト数、「h1v1」で「水平幅×垂直幅」と
画像メモリとして必要なサイズを示し、
「sizeof(Short)h1*v1」で必要なバイト数を算出する事を
意味し、「malloc(sizeof(Short)h1*v1);」でシステム
から必要な画像メモリとして領域を取得する事を意味し
ます！
そして「adr=・・・;」は、クラス「TypeArray」の画像
始点を示すメンバー変数「adr」に値をセットする事を
示します！
「if(adr==0){return(STI_MEM);}」は、
関数「malloc()」の実行結果≪システムから領域を取得す
れば、そのメモリーの（void*）ポインタ、詰り半導体
メモリーないしは仮想メモリ空間のアドレスの値を返すが
「０」＝空ポインタが関数の値として帰って来たら、
システムから領域を取得出来無かった（恐らく、許される
上限を越えた場合）≫⇒「adr==0」の条件成立はエラーが
発生したので関数の値として「STI_MEM」⇒「メモリ不足」
をエラーコードとして関数の値として返します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を
示します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を示し
ます！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示すメンバー変数「inc」に値をセットする事を
示します！
「w=2; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載
したメンバー変数」に整数型２バイト単位画素を示す
「w=2;」をセットします！
「return(END_STI);」は、正常に動作≪メモリ取得に成功≫
（２－２－４）関数「int MallocInt(int h1, int v1);」
先ず、メソッド（メンバー関数）本体を「TypeArray.cpp」
から抜き出すと
int TypeArray::MallocInt(
int h1, // 水平幅
int v1 // 垂直幅
){
if( h1 <= 0 || v1 <= 0 ){ // 幅が不正なら
return( STI_FLG ); // 不正を返す
} //
adr = (int)malloc( sizeof(int) * h1 * v1 ); // メモリを確保
if( adr == 0 ){ // 失敗時は
return( STI_MEM ); // 不正を返す
} //
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 4; // 処理単位=４BYTE
return( END_STI ); // 正常終了
}（２－２－４－Ａ）関数名「MallocInt」
「M」は、メモリー詰り、画像メモリを示す略です！
「alloc」は、英単語「allocation」アロケーションの略で
割り当て、割付を意味します！詰り、半導体メモリーを
画像メモリに割り当てる事を意味します！
「Int」は、「int型」４バイト符号有り整数型を示します！
（２－２－４－Ｂ）関数「MallocInt();」の【仮引数】説明
int TypeArray::MallocInt(
int h1, // 水平幅
int v1 // 垂直幅
){「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－２－４－Ｃ）関数「MallocInt();」の【アルゴリズム】説明
「if(h1<=0||v1<=0){return(STI_FLG);}」は、
仮引数「int h1,int v1」をエラーチェック≪
水平幅「h1」も垂直幅「v1」も０より大きい値が必要で
異なれば、関数の値として「STI_FLG」⇒引数が不正を返し
終了≫を行います！
「adr=(int)malloc(sizeof(int)h1*v1);」は、Ｃ言語標準
関数の「voidmalloc(size_t n);」と「メモリ・ブロックの
動的確保」関数です！
「sizeof(int)h1*v1」で先ず、「sizeof(int)」で
「int型」のバイト数、「h1*v1」で「水平幅×垂直幅」と
画像メモリとして必要なサイズを示し、
「sizeof(int)h1*v1」で必要なバイト数を算出する事を
意味し、「malloc(sizeof(int)h1*v1);」でシステムから
必要な画像メモリとして領域を取得する事を意味します！
そして「adr=・・・;」は、クラス「TypeArray」の画像
始点を示すメンバー変数「adr」に値をセットする事を
示します！
「if(adr==0){return(STI_MEM);}」は、
関数「malloc()」の実行結果≪システムから領域を取得
すれば、そのメモリーの（void*）ポインタ、詰り半導体
メモリーないしは仮想メモリ空間のアドレスの値を返すが、
「０」＝空ポインタが関数の値として帰って来たら、
システムから領域を取得出来無かった（恐らく、許される
上限を越えた場合）≫⇒「adr==0」の条件成立はエラーが
発生したので関数の値として「STI_MEM」⇒「メモリ不足」
をエラーコードとして関数の値として返します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を示
します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を示し
ます！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示すメンバー変数「inc」に値をセットする事を
示します！
「w=4; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載
したメンバー変数」に整数型４バイト単位画素を示す
「w=4;」をセットします！
「return(END_STI);」は、正常に動作≪メモリ取得に成功≫
（２－２－５）関数「int MallocFloat(int h1, int v1);」
先ず、メソッド（メンバー関数）本体を「TypeArray.cpp」
から抜き出すと
int TypeArray::MallocFloat(
int h1, // 水平幅
int v1 // 垂直幅
){
if( h1 <= 0 || v1 <= 0 ){ // 幅が不正なら
return( STI_FLG ); // 不正を返す
} //
adr = (int)malloc( sizeof(float) * h1 * v1 ); // メモリを確保
if( adr == 0 ){ // 失敗時は
return( STI_MEM ); // 不正を返す
} //
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 101; // 処理単位=単精度
return( END_STI ); // 正常終了
}（２－２－５－Ａ）関数名「MallocFloat」
「M」は、メモリー詰り、画像メモリを示す略です！
「alloc」は、英単語「allocation」アロケーションの略で
割り当て、割付を意味します！詰り、半導体メモリーを
画像メモリに割り当てる事を意味します！
「Float」は、「float型」単精度浮動小数点４バイト実数型
を示します！
（２－２－５－Ｂ）関数「MallocFloat();」の【仮引数】説明
int TypeArray::MallocFloat(
int h1, // 水平幅
int v1 // 垂直幅
){「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－２－５－Ｃ）関数「MallocFloat();」の【アルゴリズム】説明
){
if( h1 <= 0 || v1 <= 0 ){ // 幅が不正なら
return( STI_FLG ); // 不正を返す
} //
adr = (int)malloc( sizeof(float) * h1 * v1 ); // メモリを確保
if( adr == 0 ){ // 失敗時は
return( STI_MEM ); // 不正を返す
} //
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 101; // 処理単位=単精度
return( END_STI ); // 正常終了
}「if(h1<=0||v1<=0){return(STI_FLG);}」は、
仮引数「int h1,int v1」をエラーチェック≪
水平幅「h1」も垂直幅「v1」も０より大きい値が必要で異
なれば、関数の値として「STI_FLG」⇒引数が不正を返し
終了≫を行います！
「adr=(int)malloc(sizeof(float)h1*v1);」は、
Ｃ言語標準関数の「voidmalloc(size_t n);」と
「メモリ・ブロックの動的確保」関数です
「sizeof(float)h1*v1」で先ず、「sizeof(float)」で
「float型」のバイト数、「h1*v1」で「水平幅×垂直幅」と
画像メモリとして必要なサイズを示し、
「sizeof(float)h1*v1」で必要なバイト数を算出する事を
意味し、「malloc(sizeof(float)h1*v1);」でシステムから
必要な画像メモリとして領域を取得する事を意味します！
そして「adr=・・・;」は、クラス「TypeArray」の画像始点
を示すメンバー変数「adr」に値をセットする事を示し
ます！
「if(adr==0){return(STI_MEM);}」は、関数「malloc()」の
実行結果≪システムから領域を取得すれば、そのメモリーの
（void*）ポインタ、詰り半導体メモリーないしは仮想メモ
リ空間のアドレスの値を返すが、「０」＝空ポインタが関数
の値として帰って来たら、システムから領域を取得出来無
かった（恐らく、許される上限を越えた場合）≫⇒
「adr==0」の条件成立はエラーが発生したので関数の値と
して「STI_MEM」⇒「メモリ不足」をエラーコードとして
関数の値として返します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を示し
ます！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を
示します！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示すメンバー変数「inc」に値をセットする事を
示します！
「w=101; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載
したメンバー変数」に単精度浮動小数点４バイト単位画素を
示す「w=101;」をセットします！
「return(END_STI);」は、正常に動作≪メモリ取得に成功≫
（２－２－６）関数「int MallocDouble(int h1, int v1);」
先ず、メソッド（メンバー関数）本体を「TypeArray.cpp」
から抜き出すと
int TypeArray::MallocDouble(
int h1, // 水平幅
int v1 // 垂直幅
){
if( h1 <= 0 || v1 <= 0 ){ // 幅が不正なら
return( STI_FLG ); // 不正を返す
} //
adr = (int)malloc( sizeof(double) * h1 * v1 ); // メモリを確保
if( adr == 0 ){ // 失敗時は
return( STI_MEM ); // 不正を返す
} //
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 102; // 処理単位=倍精度
return( END_STI ); // 正常終了
}（２－２－６－Ａ）関数名「MallocDouble」
「M」は、メモリー詰り、画像メモリを示す略です！
「alloc」は、英単語「allocation」アロケーションの略で
割り当て、割付を意味します！詰り、半導体メモリーを
画像メモリに割り当てる事を意味します！
「Double」は、「double型」倍精度浮動小数点８バイト
実数型を示します！
（２－２－６－Ｂ）関数「MallocDouble();」の【仮引数】説明
int TypeArray::MallocDouble(
int h1, // 水平幅
int v1 // 垂直幅
){「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－２－６－Ｃ）関数「MallocDouble();」の【アルゴリズム】説明
){
if( h1 <= 0 || v1 <= 0 ){ // 幅が不正なら
return( STI_FLG ); // 不正を返す
} //
adr = (int)malloc( sizeof(double) * h1 * v1 ); // メモリを確保
if( adr == 0 ){ // 失敗時は
return( STI_MEM ); // 不正を返す
} //
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 102; // 処理単位=倍精度
return( END_STI ); // 正常終了
}「if(h1<=0||v1<=0){return(STI_FLG);}」は、仮引数
「int h1,int v1」をエラーチェック≪水平幅「h1」も
垂直幅「v1」も０より大きい値が必要で異なれば、関数の
値として「STI_FLG」⇒引数が不正を返し終了≫を行い
ます！
「adr=(int)malloc(sizeof(float)h1*v1);」は、Ｃ言語
標準関数の「void* malloc(size_t n);」と「メモリ・
ブロックの動的確保」関数です
「sizeof(float)h1*v1」で先ず、「sizeof(float)」で
「float型」のバイト数、「h1v1」で「水平幅×垂直幅」と
画像メモリとして必要なサイズを示し、
「sizeof(float)h1v1」で必要なバイト数を算出する事を
意味し、「malloc(sizeof(float)h1*v1);」でシステム
から必要な画像メモリとして領域を取得する事を意味しま
す！
そして「adr=・・・;」は、クラス「TypeArray」の画像
始点を示すメンバー変数「adr」に値をセットする事を
示します！
「if(adr==0){return(STI_MEM);}」は、関数「malloc()」の
実行結果≪システムから領域を取得すれば、そのメモリー
の（void*）ポインタ、詰り半導体メモリーないしは仮想
メモリ空間のアドレスの値を返すが、「０」＝空ポインタが
関数の値として帰って来たら、システムから領域を取得出来
無かった（恐らく、許される上限を越えた場合）≫⇒
「adr==0」の条件成立はエラーが発生したので関数の値と
して「STI_MEM」⇒「メモリ不足」をエラーコードとして
関数の値として返します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を
示します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を示し
ます！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示すメンバー変数「inc」に値をセットする事を
示します！
「w=102; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載
したメンバー変数」に倍単精度浮動小数点８バイト単位
画素を示す「w=102;」をセットします！
「return(END_STI);」は、正常に動作≪メモリ取得に成功≫
★注意★読者様の中には、「Ｃ＋＋」以降の動的メモリ
確保は「new」を使うのに「Ｃ言語」での
「void*malloc(size_t n);」を使うのは何故と思う人も居る
でしょうが、理由≪面倒くさいから≫⇒
「try｛【newを使用する部分等】｝catch(...){
【エラー処理】}」と例外処理（今回はメモリが確保
出来無い）を記載する必要が有るからです！
「void*malloc(size_t n);」の方が、「空ポインタ」を
確保失敗に返すので簡単だからです！
（２－３）メモリ割り当て
画像処理を扱う装置を考えると、単にシステムから動的に
メモリを取得する以外に特別なハードウェア≪
ビデオカメラからの画像をキャプチャーした画像入力用
メモリに割り当てて居るアドレス・画像を表示する為の
表示装置用のメモリーに割り当てて居るアドレス≫に
画像メモリを割り当てる必要があります！
そこでコレを使用する事で画像処理する対象の画像メモリが
割り当てられる関数です！
「TypeArray.cpp」から抜き出すと
/************************************************************************/
/***** ユーザ定義配列の作成：ＢＹＴＥ単位 *****/
/************************************************************************/
int TypeArray::SetByte(
int a, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( a <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = a; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 1; // 処理単位=ＢＹＴＥ
return( END_STI ); // 正常終了
}
/************************************************************************/
/***** ユーザ定義配列の作成：ＢＹＴＥ単位：void*設定版 *****/
/************************************************************************/
int TypeArray::SetByte(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 1; // 処理単位=ＢＹＴＥ
return( END_STI ); // 正常終了
}
/*page*/
/************************************************************************/
/***** ユーザ定義配列の作成：ｓｈｏｒｔ単位 *****/
/************************************************************************/
int TypeArray::SetShort(
int a, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( a <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = a; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 2; // 処理単位=２BYTE
return( END_STI ); // 正常終了
}
/************************************************************************/
/***** ユーザ定義配列の作成：ｓｈｏｒｔ単位：void*設定版 *****/
/************************************************************************/
int TypeArray::SetShort(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 2; // 処理単位=２BYTE
return( END_STI ); // 正常終了
}
/*page*/
/************************************************************************/
/***** ユーザ定義配列の作成：ｉｎｔ単位 *****/
/************************************************************************/
int TypeArray::SetInt(
int a, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( a <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = a; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 4; // 処理単位=４BYTE
return( END_STI ); // 正常終了
}
/************************************************************************/
/***** ユーザ定義配列の作成：ｉｎｔ単位：void*設定版 *****/
/************************************************************************/
int TypeArray::SetInt(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 4; // 処理単位=４BYTE
return( END_STI ); // 正常終了
}
/*page*/
/************************************************************************/
/***** ユーザ定義配列の作成：単精度単位 *****/
/************************************************************************/
int TypeArray::SetFloat(
int a, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( a <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = a; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 101; // 処理単位=単精度
return( END_STI ); // 正常終了
}
/************************************************************************/
/***** ユーザ定義配列の作成：単精度単位：void*設定版 *****/
/************************************************************************/
int TypeArray::SetFloat(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 101; // 処理単位=単精度
return( END_STI ); // 正常終了
}
/*page*/
/************************************************************************/
/***** ユーザ定義配列の作成：倍精度単位 *****/
/************************************************************************/
int TypeArray::SetDouble(
int a, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( a <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = a; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 102; // 処理単位=倍精度
return( END_STI ); // 正常終了
}
/************************************************************************/
/***** ユーザ定義配列の作成：倍精度単位：void*設定版 *****/
/************************************************************************/
int TypeArray::SetDouble(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 102; // 処理単位=倍精度
return( END_STI ); // 正常終了
}★注意★
「SetByte(int a,int h1,int v1);」と
「SetByte(void*p,int h1,int v1);」で判ると思いますが、
仮引数「int a,」と仮引数「void* p,」と少しだけ違う
多重定義（オーバーローディング）関数として記載して
有る事に注意して下さい！
これから、個別に解説していきます！
（２－３－１）関数「int SetByte(int a, int h1, int v1);」
int TypeArray::SetByte(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 1; // 処理単位=ＢＹＴＥ
return( END_STI ); // 正常終了
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
「Set」は、勿論、セットするです！
「Byte」は、「BYTE型」＝「unsigned char」と１バイト
符号無し整数型を示します！
何故、「Byte」と記載したかは、「英大文字」を区切り
として使用し後を小文字にして区切った表記上の
手法です！
（２－３－１－Ｂ）関数「SetByte(int a,int h1,int v1);」【仮引数】
int TypeArray::SetByte(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){「int a,」は、整数値でセットする！物理メモリーの
アドレス値です！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－３－１－Ｃ）関数「SetByte(int a,int h1,int v1);」【アルゴリズム】
「if(a<=0||h1<=0||v1<=0){return(STI_FLG);}」は、
エラーチェックです！
「a<=0」でアドレス値が０以下ならエラー、
「h1<=0||v1<=0」で水平幅・垂直幅が０以下ならエラーと
して「return(STI_FLG);」エラーコードを返し関数終了！
「adr=a;」は、仮引数「int a」をクラス「TypeArray」の
アドレスを示すメンバー変数「adr」に値をセットする事を
示します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を示
します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を
示します！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示す
メンバー変数「inc」に値をセットする事を示します！
「w=1; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載
したメンバー変数」に整数１バイト単位画素を示す
「w=1;」をセットします！
（２－３－２）関数「int SetByte(void* p, int h1,
int v1);」
因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－３－２－Ａ）関数名「SetByte();」
「Set」は、勿論、セットするです！
「Byte」は、「BYTE型」＝「unsigned char」と１バイト
符号無し整数型を示します！何故、「Byte」と記載したか
は、「英大文字」を区切りとして使用し後を小文字にして
区切った表記上の手法です！
（２－３－２－Ｂ）関数「SetByte(void* p,int h1,int v1);」【仮引数】
int TypeArray::SetByte(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){「void* p,」は、「void*」ポインタでセットする！
物理メモリーのアドレス値です！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－３－２－Ｃ）関数「SetByte(void* p,int h1,
int v1);」【アルゴリズム】
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 1; // 処理単位=ＢＹＴＥ
return( END_STI ); // 正常終了
}「if(p<=0||h1<=0||v1<=0){return(STI_FLG);}」は、
エラーチェックです！
「p<=0」でアドレス値が０以下ならエラー、
「h1<=0||v1<=0」で水平幅・
垂直幅が０以下ならエラーとして「return(STI_FLG);」
エラーコードを返し関数終了！
「adr=(int)p;」は、仮引数「void*p」を
クラス「TypeArray」のアドレスを示すメンバー変数「adr」
に値をセットする事を示します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を示し
ます！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示す
メンバー変数「v」に値をセットする事を示します！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示すメンバー変数「inc」に値をセットする事を
示します！
「w=1; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載
したメンバー変数」に整数１バイト単位画素を示す「w=1;」
をセットします！
「return(END_STI);」は、正常終了です！
（２－３－３）関数「int SetShort(int a, int h1,
int v1);」
int TypeArray::SetShort(
int a, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( a <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = a; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 2; // 処理単位=２BYTE
return( END_STI ); // 正常終了
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－３－３－Ａ）関数名「SetShort();」
「Set」は、勿論、セットするです！
「Short」は、「Short型」２バイト符号有り整数型を
示します！
（２－３－３－Ｂ）関数「SetShort(int a,int h1,
int v1);」【仮引数】
int TypeArray::SetShort(
int a, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){「int a,」は、整数値でセットする！物理メモリーの
アドレス値です！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－３－３－Ｃ）関数「SetShort(int a,int h1,
int v1);」【アルゴリズム】
){
if( a <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = a; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 2; // 処理単位=２BYTE
return( END_STI ); // 正常終了
}「if(a<=0||h1<=0||v1<=0){return(STI_FLG);}」は、
エラーチェックです！
「a<=0」でアドレス値が０以下ならエラー、
「h1<=0||v1<=0」で水平幅・垂直幅が０以下ならエラーと
して「return(STI_FLG);」エラーコードを返し関数終了！
「adr=a;」は、仮引数「int a」をクラス「TypeArray」の
アドレスを示すメンバー変数「adr」に値をセットする事を
示します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を
示します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を
示します！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示すメンバー変数「inc」に値をセットする事を
示します！
「w=2; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載
したメンバー変数」に整数１バイト単位画素を示す「w=2;」
をセットします！
「return(END_STI);」は、正常終了です！
（２－３－４）関数「int SetShort(void* p, int h1,
int v1);」
int TypeArray::SetShort(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 2; // 処理単位=２BYTE
return( END_STI ); // 正常終了
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－３－４－Ａ）関数名「SetShort();」
「Set」は、勿論、セットするです！
「Short」は、「Short型」２バイト符号有り整数型を
示します！
（２－３－４－Ｂ）関数「SetShort(void* p,int h1,
int v1);」【仮引数】
int TypeArray::SetShort(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){「void* p,」は、「void*」ポインタでセットする！
物理メモリーのアドレス値です！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－３－４－Ｃ）関数「SetShort(void* p,int h1,
int v1);」【アルゴリズム】
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 2; // 処理単位=２BYTE
return( END_STI ); // 正常終了
}「if(p<=0||h1<=0||v1<=0){return(STI_FLG);}」は、
エラーチェックです！
「p<=0」でアドレス値が０以下ならエラー、
「h1<=0||v1<=0」で水平幅・垂直幅が０以下ならエラーと
して「return(STI_FLG);」エラーコードを返し関数終了！
「adr=(int)p;」は、仮引数「void*p」をクラス
「TypeArray」のアドレスを示すメンバー変数「adr」に値を
セットする事を示します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を
示します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を
示します！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示すメンバー変数「inc」に値をセットする事を
示します！
「w=2; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載
したメンバー変数」に整数１バイト単位画素を示す
「w=2;」をセットします！
「return(END_STI);」は、正常終了です！
（２－３－５）関数「int SetInt(int a, int h1,
int v1);」
int TypeArray::SetInt(
int a, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( a <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = a; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 4; // 処理単位=４BYTE
return( END_STI ); // 正常終了
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－３－５－Ａ）関数名「SetInt();」
「Set」は、勿論、セットするです！
「Int」は、「int型」４バイト符号有り整数型を示します！
（２－３－５－Ｂ）関数「SetInt(int a,int h1,
int v1);」【仮引数】
int TypeArray::SetInt(
int a, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){「int a,」は、整数値でセットする！物理メモリーの
アドレス値です！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－３－５－Ｃ）関数「SetInt(int a,int h1,int v1);」【アルゴリズム】
){
if( a <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = a; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 4; // 処理単位=４BYTE
return( END_STI ); // 正常終了
}「if(a<=0||h1<=0||v1<=0){return(STI_FLG);}」は、
エラーチェックです！
「a<=0」でアドレス値が０以下ならエラー、
「h1<=0||v1<=0」で水平幅・垂直幅が０以下ならエラーと
して「return(STI_FLG);」エラーコードを返し関数終了！
「adr=a;」は、仮引数「int a」をクラス「TypeArray」の
アドレスを示すメンバー変数「adr」に値をセットする事を
示します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を
示します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を
示します！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示すメンバー変数「inc」に値をセットする事を
示します！
「w=4; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載
したメンバー変数」に整数型４バイト単位画素を示す
「w=4;」をセットします！
「return(END_STI);」は、正常終了です！
（２－３－６）関数「int SetInt(void* p, int h1,
int v1);」
int TypeArray::SetInt(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 4; // 処理単位=４BYTE
return( END_STI ); // 正常終了
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－３－６－Ａ）関数名「SetInt();」
「Set」は、勿論、セットするです！
「Int」は、「int型」４バイト符号有り整数型を示します！
（２－３－６－Ｂ）関数「SetInt(void* p,int h1,
int v1);」【仮引数】
int TypeArray::SetInt(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){「void* p,」は、「void*」ポインタでセットする！
物理メモリーのアドレス値です！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－３－６－Ｃ）関数「SetInt(void* p,int h1,
int v1);」【アルゴリズム】
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 4; // 処理単位=４BYTE
return( END_STI ); // 正常終了
}「if(p<=0||h1<=0||v1<=0){return(STI_FLG);}」は、
エラーチェックです！
「p<=0」でアドレス値が０以下ならエラー、
「h1<=0||v1<=0」で水平幅・垂直幅が０以下ならエラーと
して「return(STI_FLG);」エラーコードを返し関数終了！
「adr=(int)p;」は、仮引数「void*p」をクラス
「TypeArray」のアドレスを示すメンバー変数「adr」に
値をセットする事を示します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を
示します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を
示します！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示すメンバー変数「inc」に値をセットする事を
示します！
「w=4; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載し
たメンバー変数」に整数型４バイト単位画素を示す
「w=4;」をセットします！
「return(END_STI);」は、正常終了です！
（２－３－７）関数「int SetFloat(int a, int h1,
int v1);」
int TypeArray::SetFloat(
int a, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( a <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = a; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 101; // 処理単位=単精度
return( END_STI ); // 正常終了
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－３－７－Ａ）関数名「SetFloat();」
「Set」は、勿論、セットするです！
「Float」は、「float型」単精度浮動小数点４バイト実数型
を示します！
（２－３－７－Ｂ）関数「SetFloat(int a,int h1,
int v1);」【仮引数】
int TypeArray::SetFloat(
int a, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){「int a,」は、整数値でセットする！物理メモリーの
アドレス値です！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－３－７－Ｃ）関数「SetFloat(int a,int h1,
int v1);」【アルゴリズム】
){
if( a <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = a; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 101; // 処理単位=単精度
return( END_STI ); // 正常終了
}「if(a<=0||h1<=0||v1<=0){return(STI_FLG);}」は、
エラーチェックです！
「a<=0」でアドレス値が０以下ならエラー、
「h1<=0||v1<=0」で水平幅・垂直幅が０以下ならエラーと
して「return(STI_FLG);」エラーコードを返し関数終了！
「adr=a;」は、仮引数「int a」をクラス「TypeArray」の
アドレスを示すメンバー変数「adr」に値をセットする事を
示します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を
示します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を
示します！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示すメンバー変数「inc」に値をセットする事を
示します！
「w=101; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載
したメンバー変数」に単精度浮動小数点４バイト単位画素を
示す「w=101;」をセットします！
「return(END_STI);」は、正常終了です！
（２－３－８）関数「int SetFloat(void* p, int h1,
int v1);」
int TypeArray::SetFloat(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 101; // 処理単位=単精度
return( END_STI ); // 正常終了
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－３－８－Ａ）関数名「SetFloat();」
「Set」は、勿論、セットするです！
「Float」は、「float型」単精度浮動小数点４バイト
実数型を示します！
（２－３－８－Ｂ）関数「SetFloat(void* p,int h1,
int v1);」【仮引数】
int TypeArray::SetFloat(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){「void* p,」は、「void*」ポインタでセットする！
物理メモリーのアドレス値です！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－３－８－Ｃ）関数「SetFloat(void* p,int h1,
int v1);」【アルゴリズム】
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 101; // 処理単位=単精度
return( END_STI ); // 正常終了
}「if(p<=0||h1<=0||v1<=0){return(STI_FLG);}」は、
エラーチェックです！
「p<=0」でアドレス値が０以下ならエラー、
「h1<=0||v1<=0」で水平幅・垂直幅が０以下ならエラーと
して「return(STI_FLG);」エラーコードを返し関数終了！
「adr=(int)p;」は、仮引数「void*p」をクラス
「TypeArray」のアドレスを示すメンバー変数「adr」に値を
セットする事を示します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を示し
ます！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を
示します！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示すメンバー変数「inc」に値をセットする事を
示します！
「w=101; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載
したメンバー変数」に単精度浮動小数点４バイト単位画素を
示す「w=101;」をセットします！
「return(END_STI);」は、正常終了です！
（２－３－９）関数「int SetDouble(int a, int h1,
int v1);」
int TypeArray::SetDouble(
int a, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( a <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = a; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 102; // 処理単位=倍精度
return( END_STI ); // 正常終了
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－３－９－Ａ）関数名「SetDouble();」
「Set」は、勿論、セットするです！
「Double」は、「double型」倍精度浮動小数点８バイト
実数型を示します！
（２－３－９－Ｂ）関数「SetDouble(int a,int h1,
int v1);」【仮引数】
int TypeArray::SetDouble(
int a, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){「int a,」は、整数値でセットする！物理メモリーの
アドレス値です！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－３－９－Ｃ）関数「SetDouble(int a,int h1,
int v1);」【アルゴリズム】
){
if( a <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = a; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 102; // 処理単位=倍精度
return( END_STI ); // 正常終了
}「if(a<=0||h1<=0||v1<=0){return(STI_FLG);}」は、
エラーチェックです！
「a<=0」でアドレス値が０以下ならエラー、
「h1<=0||v1<=0」で水平幅・垂直幅が０以下ならエラーと
して「return(STI_FLG);」エラーコードを返し関数終了！
「adr=a;」は、仮引数「int a」をクラス「TypeArray」の
アドレスを示すメンバー変数「adr」に値をセットする事を
示します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を
示します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を
示します！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示すメンバー変数「inc」に値をセットする事を
示します！
「w=102; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載し
たメンバー変数」に倍単精度浮動小数点８バイト単位画素を
示す「w=102;」をセットします！
「return(END_STI);」は、正常終了です！
（２－３－１０）関数「int SetDouble(void* p, int h1,int v1);」
int TypeArray::SetDouble(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 102; // 処理単位=倍精度
return( END_STI ); // 正常終了
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－３－１０－Ａ）関数名「SetDouble();」
「Set」は、勿論、セットするです！
「Double」は、「double型」倍精度浮動小数点８バイト
実数型を示します！
（２－３－１０－Ｂ）関数「SetDouble(void* p,int h1,int v1);」【仮引数】
int TypeArray::SetDouble(
void* p, // アドレス
int h1, // 水平幅
int v1 // 垂直幅
){「void* p,」は、「void*」ポインタでセットする！
物理メモリーのアドレス値です！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－３－１０－Ｃ）関数「SetDouble(void* p,int h1,int v1);」【アルゴリズム】
){
if( p <= 0 || h1 <= 0 || v1 <= 0 ){ // アドレスと幅が不正
return( STI_FLG ); // なら、不正を返す
} //
adr = (int)p; // アドレスを設定
h = h1; // 水平幅設定
v = v1; // 垂直幅設定
inc = h1; // インクリ幅設定
w = 102; // 処理単位=倍精度
return( END_STI ); // 正常終了
}「if(p<=0||h1<=0||v1<=0){return(STI_FLG);}」は、
エラーチェックです！
「p<=0」でアドレス値が０以下ならエラー、
「h1<=0||v1<=0」で水平幅・垂直幅が０以下ならエラーと
して「return(STI_FLG);」エラーコードを返し関数終了！
「adr=(int)p;」は、仮引数「void*p」をクラス
「TypeArray」のアドレスを示すメンバー変数「adr」に値を
セットする事を示します！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を
示します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を
示します！
「inc=h1;」は、仮引数「int h1」をクラス「TypeArray」の
増加幅を示すメンバー変数「inc」に値をセットする事を
示します！
「w=102; 」は、クラス「TypeArray」の「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載し
たメンバー変数」に倍単精度浮動小数点８バイト単位画素を
示す「w=102;」をセットします！
「return(END_STI);」は、正常終了です！
★注意★ここまででクラス「TypeArray」へ半導体メモリー
及び仮想メモリの割り当てを行う関数です！
次から、部分画像に対する処理を述べます！
（２－４）部分画像
上図の様に解説『画像メモリ概要』で説明した！元の画像≪
システムから取得「Malloc()系関数群」及び特定アドレスの
半導体メモリを割付「SetByte()系」≫を元の画像として
その部分を使用する部分画像を使用する事が出来ます！
コレを使用する事で画像処理する対象の画像メモリが割り
当てられる関数です！「TypeArray.h」から抜き出すと
int subset( // 部分配列の定義
TypeArray* orgPtr, // 元へのポインタ
int x, int y, // 始点ｘｙ座標
int h1, int v1 ); // 水平・垂直幅
int subsetAdjust( // 部分配列の定義：幅自動調整
TypeArray* orgPtr, // 元へのポインタ
int x, int y, // 始点ｘｙ座標
int h1, int v1 ); // 水平・垂直幅
int subsetBMP( // 部分配列の定義：表示用ＢＭＰ専用
TypeArray* orgPtr, // 元へのポインタ
int x, int y, // 始点ｘｙ座標：カラー画素単位
int h1, int v1 ); // 水平・垂直幅：カラー画素単位
int subsetRev( // 部分配列の定義：表示用ＢＭＰ専用
TypeArray* orgPtr, // 元へのポインタ
int x, int y, // 始点ｘｙ座標：個別画素単位
int h1, int v1 ); // 水平・垂直幅：個別画素単位
これから、個別に解説していきます！
（２－４－１）関数「int subset(TypeArray*orgPtr,int x,int y,int h1,int v1);」
int TypeArray::subset(
TypeArray* orgPtr, // 元の情報Ptr
int x, // 始点ｘ座標
int y, // 始点ｙ座標
int h1, // 水平幅
int v1 // 垂直幅
){
if( x < 0 || y < 0 || h1 <= 0 || v1 <= 0 // 範囲指定に誤りが
|| x + h1 > orgPtr->h || y + v1 > orgPtr->v ){ // あれば
adr = 0; // 無効をセットし
return( STI_FLG ); // 左記を返す
} //
if( orgPtr->w == 1 ){ // BYTE単位ならば
adr = orgPtr->adr + x + y * orgPtr->inc; // 左記アドレス演算
}else if( orgPtr->w == 2 ){ // 2BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 2; // 左記アドレス演算
}else if( orgPtr->w == 4 || orgPtr->w == 101 ){ // 4BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 4; // 左記アドレス演算
}else{ // 8BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 8; // 左記アドレス演算
} //
h = h1; // 水平幅を設定
v = v1; // 垂直幅を設定
inc = orgPtr->inc; // 増加幅をコピー
w = orgPtr->w; // 単位幅をコピー
return( END_STI ); // 正常終了
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－４－１－Ａ）関数名「subset();」
「subset」は、サブセット、日本語でも部分を表す用語と
して今は、認知されている筈ですね！
ここでは、元の画像の一部をサブセットとして部分画像を
切り取る事を意味します！
（２－４－１－Ｂ）関数「subset();」【仮引数】
int TypeArray::subset(
TypeArray* orgPtr, // 元の情報Ptr
int x, // 始点ｘ座標
int y, // 始点ｙ座標
int h1, // 水平幅
int v1 // 垂直幅
){「TypeArray* orgPtr,」は、元の画像を示すクラス
「TypeArray型」を示すポインタです！
「int x,」は、元の画像のＸ座標で部分画像の切り取る
始点です！
「int y,」は、元の画像のＹ座標で部分画像の切り取る
始点です！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－４－１－Ｃ）関数「subset();」【アルゴリズム】
){
if( x < 0 || y < 0 || h1 <= 0 || v1 <= 0 // 範囲指定に誤りが
|| x + h1 > orgPtr->h || y + v1 > orgPtr->v ){ // あれば
adr = 0; // 無効をセットし
return( STI_FLG ); // 左記を返す
} //
if( orgPtr->w == 1 ){ // BYTE単位ならば
adr = orgPtr->adr + x + y * orgPtr->inc; // 左記アドレス演算
}else if( orgPtr->w == 2 ){ // 2BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 2; // 左記アドレス演算
}else if( orgPtr->w == 4 || orgPtr->w == 101 ){ // 4BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 4; // 左記アドレス演算
}else{ // 8BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 8; // 左記アドレス演算
} //
h = h1; // 水平幅を設定
v = v1; // 垂直幅を設定
inc = orgPtr->inc; // 増加幅をコピー
w = orgPtr->w; // 単位幅をコピー
return( END_STI ); // 正常終了
}「if(・・条件・・{・・成立中身・・}」は、
条件「x<0||y<0||h1<=0||v1<=0||x+h1>orgPtr->h||
y+v1>orgPtr->v」で
「x<0||y<0」とＸＹ座標が負の値か「h1<=0||v1<=0」と
水平幅・垂直幅が０以下、若しくは、「x+h1>orgPtr->h」と
部分画像の右端（x+h1）が元画像の外（orgPtr->hと元の
水平幅を越えた）と部分画像の下端（y+v1）が元画像の
外（orgPtr->vと元の垂直幅を越えた）場合は、
成立中身「adr=0;return(STI_FLG);」でクラス
「TypeArray型」を初期化「adr=0;」し、
エラーコード「STI_FLG」を返し関数終了！
次に「if(orgPtr->w==1){
adr=orgPtr->adr+x+y*orgPtr->inc;」は、元画像の画素単位
＝１バイトの場合、「orgPtr->adr+x+y*orgPtr->inc」と
部分画像の切り取りアドレスを算出しクラス「TypeArray」
のアドレスを示すメンバー変数「adr」に値をセットした
事を示します！
「}else if(orgPtr->w==2){
adr=orgPtr->adr+(x+y*orgPtr->inc)2;」は、
元画像の画素単位＝２バイトの場合、
「orgPtr->adr+(x+yorgPtr->inc)2」と
部分画像の切り取りアドレスを算出しクラス
「TypeArray」のアドレスを示すメンバー変数「adr」に値を
セットした事を示します！勿論、増加分
「}elseif(orgPtr->w==4||orgPtr->w==101){
adr=orgPtr->adr+(x+y*orgPtr->inc)*4;」と「4」と
４バイト画素に合わせて居ます！「orgPtr->w==4」は
整数型の４バイト画素、
「orgPtr->w==101」は、単精度浮動小数点だから４バイト
画素です！
元画像の画素単位＝４バイトの場合、
「orgPtr->adr+(x+y*orgPtr->inc)4」と部分画像の切り
取りアドレスを算出しクラス「TypeArray」のアドレスを
示すメンバー変数「adr」に値をセットした事を示します！
勿論、増加分
「(x+y*orgPtr->inc)*4」と「4」と４バイト画素に
合わせて居ます！
「}else{adr=orgPtr->adr+(x+y*orgPtr->inc)*8;}」は、
勿論、残りの種類の画素が倍精度浮動小数点８バイト画素の
場合です！
クラス「TypeArray型」にセットされている「orgPtr->w」に
は、セットする関数で必ず「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載し
たメンバー変数」として残りは８バイト単位画素です！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を
示します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を
示します！
「inc=orgPtr->inc;」は、元画像の増加幅を部分画像に
継承した事を示します！
「w=orgPtr->w;」は、元画像の画素の種類（
1/2/4BYTE,101:単精度,102:倍精度）を部分画像に継承した
事を示します！
「return(END_STI);」は、正常終了です！
（２－４－２）関数「int subsetAdjust(TypeArray*orgPtr,int x,int y,int h1,int v1);」
int TypeArray::subsetAdjust(
TypeArray* orgPtr, // 元の情報Ptr
int x, // 始点ｘ座標
int y, // 始点ｙ座標
int h1, // 水平幅
int v1 // 垂直幅
){
if( x < 0 || y < 0 || h1 <= 0 || v1 <= 0 // 範囲指定に誤りが
|| x >= orgPtr->h || y >= orgPtr->v ){ // あれば
adr = 0; // 無効をセットし
return( STI_FLG ); // 左記を返す
} //
if( h1 + x > orgPtr->h ){ // 水平幅がOver時
h1 = orgPtr->h - x; // 左記で範囲内に調整
} //
if( v1 + y > orgPtr->v ){ // 垂直幅がOver時
v1 = orgPtr->v - y; // 左記で範囲内に調整
} //
if( orgPtr->w == 1 ){ // BYTE単位ならば
adr = orgPtr->adr + x + y * orgPtr->inc; // 左記アドレス演算
}else if( orgPtr->w == 2 ){ // 2BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 2; // 左記アドレス演算
}else if( orgPtr->w == 4 || orgPtr->w == 101 ){ // 4BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 4; // 左記アドレス演算
}else{ // 8BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 8; // 左記アドレス演算
} //
h = h1; // 水平幅を設定
v = v1; // 垂直幅を設定
inc = orgPtr->inc; // 増加幅をコピー
w = orgPtr->w; // 単位幅をコピー
return( END_STI ); // 正常終了
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－４－２－Ａ）関数名「subsetAdjust();」
「subset」は、サブセット、日本語でも部分を表す用語と
して今は、認知されている筈ですね！
ここでは、元の画像の一部をサブセットとして部分画像を
切り取る事を意味します！
「Adjust」は、英単語で日本語としては調整です！
ここでは、部分画像が元画像の範囲を超えた場合に収まる
様にサイズ調整を行う意味です！
（２－４－２－Ｂ）関数「subsetAdjust();」【仮引数】
int TypeArray::subsetAdjust(
TypeArray* orgPtr, // 元の情報Ptr
int x, // 始点ｘ座標
int y, // 始点ｙ座標
int h1, // 水平幅
int v1 // 垂直幅
){「TypeArray* orgPtr,」は、元の画像を示すクラス
「TypeArray型」を示すポインタです！
「int x,」は、元の画像のＸ座標で部分画像の切り取る始点
です！
「int y,」は、元の画像のＹ座標で部分画像の切り取る始点
です！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－４－２－Ｃ）関数「subsetAdjust();」
【アルゴリズム】
){
if( x < 0 || y < 0 || h1 <= 0 || v1 <= 0 // 範囲指定に誤りが
|| x >= orgPtr->h || y >= orgPtr->v ){ // あれば
adr = 0; // 無効をセットし
return( STI_FLG ); // 左記を返す
} //
if( h1 + x > orgPtr->h ){ // 水平幅がOver時
h1 = orgPtr->h - x; // 左記で範囲内に調整
} //
if( v1 + y > orgPtr->v ){ // 垂直幅がOver時
v1 = orgPtr->v - y; // 左記で範囲内に調整
} //
if( orgPtr->w == 1 ){ // BYTE単位ならば
adr = orgPtr->adr + x + y * orgPtr->inc; // 左記アドレス演算
}else if( orgPtr->w == 2 ){ // 2BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 2; // 左記アドレス演算
}else if( orgPtr->w == 4 || orgPtr->w == 101 ){ // 4BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 4; // 左記アドレス演算
}else{ // 8BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 8; // 左記アドレス演算
} //
h = h1; // 水平幅を設定
v = v1; // 垂直幅を設定
inc = orgPtr->inc; // 増加幅をコピー
w = orgPtr->w; // 単位幅をコピー
return( END_STI ); // 正常終了
}「if(・・条件・・{・・成立中身・・}」は、
条件「x<0||y<0||h1<=0||v1<=0||x>=orgPtr->h||
y>=orgPtr->v」で「x<0||y<0」とＸＹ座標が負の値か
「h1<=0||v1<=0」と水平幅・垂直幅が０以下の値、
若しくは、「x>orgPtr->h」と部分画像の左端（x）が
元画像の外（orgPtr->hと元の水平幅を越えた）と部分画像
の下端（y）が元画像の外（orgPtr->vと元の垂直幅を
越えた）場合は、
成立中身「adr=0;return(STI_FLG);」で
クラス「TypeArray型」を初期化「adr=0;」し、
エラーコード「STI_FLG」を返し関数終了！
次に「if(h1+x>orgPtr->h){h1=orgPtr->h-x;}」は、
部分画像の右端が越えて居た場合、最大のサイズに部分
画像の水平幅を調整します！
「if(v1+y>orgPtr->v){v1=orgPtr->v-y;}」は、
部分画像の下端が越えて居た場合、最大のサイズに部分
画像の垂直幅を調整します！
「if(orgPtr->w==1){adr=orgPtr->adr+x+y*orgPtr->inc;」
は、元画像の画素単位＝１バイトの場合、
「orgPtr->adr+x+y*orgPtr->inc」と部分画像の切り取り
アドレスを算出しクラス「TypeArray」のアドレスを示す
メンバー変数「adr」に値をセットした事を示します！
「}else if(orgPtr->w==2){adr=orgPtr->adr+
(x+y*orgPtr->inc)2;」は、元画像の画素単位＝２バイト
の場合、「orgPtr->adr+(x+y*orgPtr->inc)2」と
部分画像の切り取りアドレスを算出しクラス
「TypeArray」のアドレスを示すメンバー変数「adr」に値を
セットした事を示します！勿論、増加分
「}elseif(orgPtr->w==4||orgPtr->w==101){
adr=orgPtr->adr+(x+y*orgPtr->inc)*4;」と「4」と
４バイト画素に合わせて居ます！「orgPtr->w==4」は
整数型の４バイト画素、「orgPtr->w==101」は、
単精度浮動小数点だから４バイト画素です！
元画像の画素単位＝４バイトの場合、
「orgPtr->adr+(x+y*orgPtr->inc)4」と部分画像の切り
取りアドレスを算出しクラス「TypeArray」のアドレスを
示すメンバー変数「adr」に値をセットした事を示します！
勿論、増加分「(x+y*orgPtr->inc)*4」と「4」と
４バイト画素に合わせて居ます！
「}else{adr=orgPtr->adr+(x+y*orgPtr->inc)*8;}」は、
勿論、残りの種類の画素が倍精度浮動小数点８バイト画素の
場合です！
クラス「TypeArray型」にセットされている「orgPtr->w」
には、セットする関数で必ず「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載し
たメンバー変数」として残りは８バイト単位画素です！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を
示します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を
示します！
「inc=orgPtr->inc;」は、元画像の増加幅を部分画像に
継承した事を示します！
「w=orgPtr->w;」は、元画像の画素の種類（
1/2/4BYTE,101:単精度,102:倍精度）を部分画像に継承
した事を示します！
「return(END_STI);」は、正常終了です！
（２－４－３）関数「int subsetBMP(TypeArray*orgPtr,
int x,int y,int h1,int v1);」
int TypeArray::subsetBMP(
TypeArray* orgPtr, // 元の情報Ptr
int x, // 始点ｘ座標：カラー画素単位
int y, // 始点ｙ座標：カラー画素単位
int h1, // 水平幅：カラー画素単位
int v1 // 垂直幅：カラー画素単位
){
x *= 3; // Ｘ座標を３倍する
y = orgPtr->v - ( y + v1 ); // Ｙ座標を上下逆にする
h1 *= 3; // 水平幅を３倍する
if( x < 0 || y < 0 || h1 <= 0 || v1 <= 0 // 範囲指定に誤りが
|| x >= orgPtr->h || y >= orgPtr->v ){ // あれば
adr = 0; // 無効をセットし
return( STI_FLG ); // 左記を返す
} //
if( h1 + x > orgPtr->h ){ // 水平幅がOver時
h1 = orgPtr->h - x; // 左記で範囲内に調整
} //
if( v1 + y > orgPtr->v ){ // 垂直幅がOver時
v1 = orgPtr->v - y; // 左記で範囲内に調整
} //
if( orgPtr->w == 1 ){ // BYTE単位ならば
adr = orgPtr->adr + x + y * orgPtr->inc; // 左記アドレス演算
}else if( orgPtr->w == 2 ){ // 2BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 2; // 左記アドレス演算
}else if( orgPtr->w == 4 || orgPtr->w == 101 ){ // 4BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 4; // 左記アドレス演算
}else{ // 8BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 8; // 左記アドレス演算
} //
h = h1; // 水平幅を設定
v = v1; // 垂直幅を設定
inc = orgPtr->inc; // 増加幅をコピー
w = orgPtr->w; // 単位幅をコピー
return( END_STI ); // 正常終了
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－４－３－Ａ）関数名「subsetBMP();」
「subset」は、サブセット、日本語でも部分を表す用語と
して今は、認知されている筈ですね！
ここでは、元の画像の一部をサブセットとして部分画像を
切り取る事を意味します！
「BMP」は、クラス化した時にターゲットにした
コンピュータシステムが、WindowsＸＰでそこで使用して
いる表示用の画像メモリ構造がＢＭＰです！
（２－４－３－Ｂ）関数「subsetBMP();」【仮引数】
int TypeArray::subsetBMP(
TypeArray* orgPtr, // 元の情報Ptr
int x, // 始点ｘ座標：カラー画素単位
int y, // 始点ｙ座標：カラー画素単位
int h1, // 水平幅：カラー画素単位
int v1 // 垂直幅：カラー画素単位
){「TypeArray* orgPtr,」は、元の画像を示すクラス
「TypeArray型」を示すポインタです！
「int x,」は、元の画像のＸ座標で部分画像の切り取る
始点です！
「int y,」は、元の画像のＹ座標で部分画像の切り取る
始点です！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－４－３－Ｃ）関数「subsetBMP();」【アルゴリズム】
){
x *= 3; // Ｘ座標を３倍する
y = orgPtr->v - ( y + v1 ); // Ｙ座標を上下逆にする
h1 *= 3; // 水平幅を３倍する
if( x < 0 || y < 0 || h1 <= 0 || v1 <= 0 // 範囲指定に誤りが
|| x >= orgPtr->h || y >= orgPtr->v ){ // あれば
adr = 0; // 無効をセットし
return( STI_FLG ); // 左記を返す
} //
if( h1 + x > orgPtr->h ){ // 水平幅がOver時
h1 = orgPtr->h - x; // 左記で範囲内に調整
} //
if( v1 + y > orgPtr->v ){ // 垂直幅がOver時
v1 = orgPtr->v - y; // 左記で範囲内に調整
} //
if( orgPtr->w == 1 ){ // BYTE単位ならば
adr = orgPtr->adr + x + y * orgPtr->inc; // 左記アドレス演算
}else if( orgPtr->w == 2 ){ // 2BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 2; // 左記アドレス演算
}else if( orgPtr->w == 4 || orgPtr->w == 101 ){ // 4BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 4; // 左記アドレス演算
}else{ // 8BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 8; // 左記アドレス演算
} //
h = h1; // 水平幅を設定
v = v1; // 垂直幅を設定
inc = orgPtr->inc; // 増加幅をコピー
w = orgPtr->w; // 単位幅をコピー
return( END_STI ); // 正常終了
}「x*=3;」は、表示画像は、光の３原色「Ｒ(赤)Ｇ(緑)
Ｂ(青)」を表す３画素≪何故か、WindowsＸＰではＢＧＲと
青緑赤の順番に並んだ構造≫に成るので、ココで切り取る
Ｘ座標方向の値をＢＭＰ用に調整！
「y=orgPtr->v-(y+v1);」は、WindowsＸＰでは、如何も
表示用の幾何学的な象限を第Ⅰ象限に設定しているラシク、
メモリ構造を一旦、上下逆さまに成る為の処置でＹ座標
方向の値をＢＭＰ用に調整！
「if(・・条件・・{・・成立中身・・}」は、
条件「x<0||y<0||h1<=0||v1<=0||x>=orgPtr->h||
y>=orgPtr->v」で
「x<0||y<0」とＸＹ座標が負の値か「h1<=0||v1<=0」と
水平幅・垂直幅が０以下の値、若しくは、「x>orgPtr->h」
と部分画像の左端（x）が元画像の外（orgPtr->hと元の
水平幅を越えた）と部分画像の下端（y）が元画像の外
（orgPtr->vと元の垂直幅を越えた）場合は、成立中身
「adr=0;return(STI_FLG);」でクラス「TypeArray型」を
初期化「adr=0;」し、エラーコード「STI_FLG」を返し関数
終了！
次に「if(h1+x>orgPtr->h){h1=orgPtr->h-x;}」は、
部分画像の右端が越えて居た場合、最大のサイズに部分
画像の水平幅を調整します！
「if(v1+y>orgPtr->v){v1=orgPtr->v-y;}」は、部分画像の
下端が越えて居た場合、最大のサイズに部分画像の垂直幅を
調整します！
「if(orgPtr->w==1){adr=orgPtr->adr+x+y*orgPtr->inc;」
は、元画像の画素単位＝１バイトの場合、
「orgPtr->adr+x+y*orgPtr->inc」と部分画像の切り取り
アドレスを算出しクラス「TypeArray」のアドレスを示す
メンバー変数「adr」に値をセットした事を示します！
「}else if(orgPtr->w==2){
adr=orgPtr->adr+(x+y*orgPtr->inc)*2;」は、
元画像の画素単位＝２バイトの場合、
「orgPtr->adr+(x+y*orgPtr->inc)*2」と
部分画像の切り取りアドレスを算出しクラス「TypeArray」
のアドレスを示すメンバー変数「adr」に値をセットした
事を示します！
勿論、増加分「}elseif(orgPtr->w==4||orgPtr->w==101){
adr=orgPtr->adr+(x+yorgPtr->inc)4;」と「4」と
４バイト画素に合わせて居ます！「orgPtr->w==4」は
整数型の４バイト画素、「orgPtr->w==101」は、
単精度浮動小数点だから４バイト画素です！
元画像の画素単位＝４バイトの場合、
「orgPtr->adr+(x+yorgPtr->inc)4」と部分画像の切り
取りアドレスを算出しクラス「TypeArray」のアドレスを
示すメンバー変数「adr」に値をセットした事を示します！
勿論、増加分「(x+yorgPtr->inc)4」と「4」と
４バイト画素に合わせて居ます！
「}else{adr=orgPtr->adr+(x+y*orgPtr->inc)*8;}」は、
勿論、残りの種類の画素が倍精度浮動小数点８バイト画素の
場合です！
クラス「TypeArray型」にセットされている「orgPtr->w」
には、セットする関数で必ず「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載し
たメンバー変数」として残りは８バイト単位画素です！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を
示します！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を
示します！
「inc=orgPtr->inc;」は、元画像の増加幅を部分画像に
継承した事を示します！
「w=orgPtr->w;」は、元画像の画素の種類（
1/2/4BYTE,101:単精度,102:倍精度）を部分画像に継承した
事を示します！
「return(END_STI);」は、正常終了です！
（２－４－４）関数「int subsetRev(TypeArray*orgPtr,
int x,int y,int h1,int v1);」
int TypeArray::subsetRev(
TypeArray* orgPtr, // 元の情報Ptr
int x, // 始点ｘ座標：個別画素単位
int y, // 始点ｙ座標：個別画素単位
int h1, // 水平幅：個別画素単位
int v1 // 垂直幅：個別画素単位
){
y = orgPtr->v - ( y + v1 ); // Ｙ座標を上下逆にする
if( x < 0 || y < 0 || h1 <= 0 || v1 <= 0 // 範囲指定に誤りが
|| x >= orgPtr->h || y >= orgPtr->v ){ // あれば
adr = 0; // 無効をセットし
return( STI_FLG ); // 左記を返す
} //
if( h1 + x > orgPtr->h ){ // 水平幅がOver時
h1 = orgPtr->h - x; // 左記で範囲内に調整
} //
if( v1 + y > orgPtr->v ){ // 垂直幅がOver時
v1 = orgPtr->v - y; // 左記で範囲内に調整
} //
if( orgPtr->w == 1 ){ // BYTE単位ならば
adr = orgPtr->adr + x + y * orgPtr->inc; // 左記アドレス演算
}else if( orgPtr->w == 2 ){ // 2BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 2; // 左記アドレス演算
}else if( orgPtr->w == 4 || orgPtr->w == 101 ){ // 4BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 4; // 左記アドレス演算
}else{ // 8BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 8; // 左記アドレス演算
} //
h = h1; // 水平幅を設定
v = v1; // 垂直幅を設定
inc = orgPtr->inc; // 増加幅をコピー
w = orgPtr->w; // 単位幅をコピー
return( END_STI ); // 正常終了
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－４－４－Ａ）関数名「subsetRev();」
「subset」は、サブセット、日本語でも部分を表す用語と
して今は、認知されている筈ですね！
ここでは、元の画像の一部をサブセットとして部分画像を
切り取る事を意味します！
「Rev」は、クラス化した時にターゲットにした
コンピュータシステムが、WindowsＸＰでそこで使用して
いる表示用の画像メモリ構造がＢＭＰですと関数名
「subsetBMP();」に記載しましたが、ここでは、
英単語「reverse」⇒単に逆転の意味でＹ座標を上下逆に
した事を意味します！
（２－４－４－Ｂ）関数「subsetRev();」【仮引数】
int TypeArray::subsetRev(
TypeArray* orgPtr, // 元の情報Ptr
int x, // 始点ｘ座標：個別画素単位
int y, // 始点ｙ座標：個別画素単位
int h1, // 水平幅：個別画素単位
int v1 // 垂直幅：個別画素単位
){「TypeArray* orgPtr,」は、元の画像を示すクラス
「TypeArray型」を示すポインタです！
「int x,」は、元の画像のＸ座標で部分画像の切り取る
始点です！
「int y,」は、元の画像のＹ座標で部分画像の切り取る
始点です！
「int h1,」は、水平幅です！
「int v1 」は、垂直幅です！
（２－４－４－Ｃ）関数「subsetRev();」【アルゴリズム】
){
y = orgPtr->v - ( y + v1 ); // Ｙ座標を上下逆にする
if( x < 0 || y < 0 || h1 <= 0 || v1 <= 0 // 範囲指定に誤りが
|| x >= orgPtr->h || y >= orgPtr->v ){ // あれば
adr = 0; // 無効をセットし
return( STI_FLG ); // 左記を返す
} //
if( h1 + x > orgPtr->h ){ // 水平幅がOver時
h1 = orgPtr->h - x; // 左記で範囲内に調整
} //
if( v1 + y > orgPtr->v ){ // 垂直幅がOver時
v1 = orgPtr->v - y; // 左記で範囲内に調整
} //
if( orgPtr->w == 1 ){ // BYTE単位ならば
adr = orgPtr->adr + x + y * orgPtr->inc; // 左記アドレス演算
}else if( orgPtr->w == 2 ){ // 2BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 2; // 左記アドレス演算
}else if( orgPtr->w == 4 || orgPtr->w == 101 ){ // 4BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 4; // 左記アドレス演算
}else{ // 8BYTE単位ならば
adr = orgPtr->adr + ( x + y * orgPtr->inc ) * 8; // 左記アドレス演算
} //
h = h1; // 水平幅を設定
v = v1; // 垂直幅を設定
inc = orgPtr->inc; // 増加幅をコピー
w = orgPtr->w; // 単位幅をコピー
return( END_STI ); // 正常終了
}「y=orgPtr->v-(y+v1);」は、WindowsＸＰでは、如何も
表示用の幾何学的な象限を第Ⅰ象限に設定している
ラシク、メモリ構造を一旦、上下逆さまに成る為の処置で
Ｙ座標方向の値をＢＭＰ用に調整！
「if(・・条件・・{・・成立中身・・}」は、
条件「x<0||y<0||h1<=0||v1<=0||x>=orgPtr->h||
y>=orgPtr->v」で「x<0||y<0」とＸＹ座標が負の値か
「h1<=0||v1<=0」と水平幅・垂直幅が０以下の値、
若しくは、「x>orgPtr->h」と部分画像の左端（x）が
元画像の外（orgPtr->hと元の水平幅を越えた）と
部分画像の下端（y）が元画像の外（orgPtr->vと元の
垂直幅を越えた）場合は、成立中身
「adr=0;return(STI_FLG);」でクラス「TypeArray型」を
初期化「adr=0;」し、エラーコード「STI_FLG」を返し
関数終了！
次に「if(h1+x>orgPtr->h){h1=orgPtr->h-x;}」は、
部分画像の右端が越えて居た場合、最大のサイズに部分
画像の水平幅を調整します！
「if(v1+y>orgPtr->v){v1=orgPtr->v-y;}」は、
部分画像の下端が越えて居た場合、最大のサイズに部分画像
の垂直幅を調整します！
「if(orgPtr->w==1){adr=orgPtr->adr+x+y*orgPtr->inc;」
は、元画像の画素単位＝１バイトの場合、
「orgPtr->adr+x+y*orgPtr->inc」と部分画像の切り取り
アドレスを算出しクラス「TypeArray」のアドレスを示す
メンバー変数「adr」に値をセットした事を示します！
「}else if(orgPtr->w==2){
adr=orgPtr->adr+(x+y*orgPtr->inc)*2;」は、元画像の
画素単位＝２バイトの場合、
「orgPtr->adr+(x+y*orgPtr->inc)*2」と
部分画像の切り取りアドレスを算出しクラス「TypeArray」
のアドレスを示すメンバー変数「adr」に値をセットした
事を示します！
勿論、増加分「}elseif(orgPtr->w==4||orgPtr->w==101){
adr=orgPtr->adr+(x+y*orgPtr->inc)*4;」と「4」と
４バイト画素に合わせて居ます！「orgPtr->w==4」は
整数型の４バイト画素、
「orgPtr->w==101」は、単精度浮動小数点だから
４バイト画素です！
元画像の画素単位＝４バイトの場合、
「orgPtr->adr+(x+y*orgPtr->inc)*4」と部分画像の切り
取りアドレスを算出しクラス「TypeArray」のアドレスを
示すメンバー変数「adr」に値をセットした事を示します！
勿論、増加分「(x+y*orgPtr->inc)*4」と「4」と
４バイト画素に合わせて居ます！
「}else{adr=orgPtr->adr+(x+y*orgPtr->inc)*8;}」は、
勿論、残りの種類の画素が倍精度浮動小数点８バイト画素の
場合です！
クラス「TypeArray型」にセットされている「orgPtr->w」
には、セットする関数で必ず「処理幅（
1/2/4BYTE,101:単精度,102:倍精度）とコメントでは記載
したメンバー変数」として残りは８バイト単位画素です！
「h=h1;」は、仮引数「int h1」をクラス「TypeArray」の
水平幅を示すメンバー変数「h」に値をセットする事を示し
ます！
「v=v1;」は、仮引数「int v1」をクラス「TypeArray」の
垂直幅を示すメンバー変数「v」に値をセットする事を
示します！
「inc=orgPtr->inc;」は、元画像の増加幅を部分画像に
継承した事を示します！
「w=orgPtr->w;」は、元画像の画素の種類（
1/2/4BYTE,101:単精度,102:倍精度）を部分画像に継承した
事を示します！
「return(END_STI);」は、正常終了です！
★備考★「Ｎｏｔｅ投稿用エディタで変な特徴」≪
半角「*」がコピペしてＰＣ上のテキストファイルから
ペーストする時に消える場合が在る！今回、良く起こった
のは「y*orgPtr->inc」と乗算が消え「yorgPtr->inc」
との表現や、仮引数「TypeArray* orgPtr,」が
「TypeArray orgPtr,」≫と成り、手作業で編集を一文字
づつ行った事です！恐らく、Ｃｏｄｅ機能でソースコード
を表示して居る所は、変な事が起きずに表示して居ると思
いますので本文で変な所が有れば、見比べて確認して
下さい！見落としが、残って居る可能性が有ります！
取り敢えず、今日は、ココまで疲れた？！
また、これは近々続きの講義を始めますのでココまでは、
理解して下さい！！
２０２４年１月３０継続講義
（２－５）画素の操作
（２－５－１）関数「int get(int x,int y);」
int TypeArray::get(
int x, // 始点ｘ座標
int y // 始点ｙ座標
){
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v ){ // アドレスや座標が不正
return( STI_FLG ); // なら、不正を返す
} //
if( w == 1 ){ // １ＢＹＴＥなら
BYTE* p = (BYTE*)adr + x + y * inc; // 左記でポイント演算
return( *p ); // ポインタで指す値を返す
}else if( w == 2 ){ // ２ＢＹＴＥなら
short* p = (short*)adr + x + y * inc; // 左記でポイント演算
return( *p ); // ポインタで指す値を返す
}else if( w == 4 ){ // ４ＢＹＴＥなら
int* p = (int*)adr + x + y * inc; // 左記でポイント演算
return( *p ); // ポインタで指す値を返す
}else if( w == 101 ){ // 単精度なら
float* p = (float*)adr + x + y * inc; // 左記でポイント演算
return( (int)*p ); // ポインタで指す値を返す
}else if( w == 102 ){ // 倍精度なら
double* p = (double*)adr + x + y * inc; // 左記でポイント演算
return( (int)*p ); // ポインタで指す値を返す
}else{ // その他なら
return( STI_FLG ); // 不正を返す
} //
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－５－１－Ａ）関数名「int get(int x,int y);」
「get」は、ゲット、日本語でも取得するを意味する用語
として今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素を取り出す事を意味
します！
（２－５－１－Ｂ）関数「get();」【仮引数】
int TypeArray::get(
int x, // 始点ｘ座標
int y // 始点ｙ座標
){「int x,」は、元の画像のＸ座標です！
「int y,」は、元の画像のＹ座標です！
（２－５－１－Ｃ）関数「get();」【アルゴリズム】
){
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v ){ // アドレスや座標が不正
return( STI_FLG ); // なら、不正を返す
} //
if( w == 1 ){ // １ＢＹＴＥなら
BYTE* p = (BYTE*)adr + x + y * inc; // 左記でポイント演算
return( *p ); // ポインタで指す値を返す
}else if( w == 2 ){ // ２ＢＹＴＥなら
short* p = (short*)adr + x + y * inc; // 左記でポイント演算
return( *p ); // ポインタで指す値を返す
}else if( w == 4 ){ // ４ＢＹＴＥなら
int* p = (int*)adr + x + y * inc; // 左記でポイント演算
return( *p ); // ポインタで指す値を返す
}else if( w == 101 ){ // 単精度なら
float* p = (float*)adr + x + y * inc; // 左記でポイント演算
return( (int)*p ); // ポインタで指す値を返す
}else if( w == 102 ){ // 倍精度なら
double* p = (double*)adr + x + y * inc; // 左記でポイント演算
return( (int)*p ); // ポインタで指す値を返す
}else{ // その他なら
return( STI_FLG ); // 不正を返す
} //
}「if(adr<=0||x<0||x>=h||y<0||y>=v){return(STI_FLG);}」
は、条件「adr<=0||x<0||x>=h||y<0||y>=v」で「adr<=0」
で画像が不正、「x<0||x>=h||y<0||y>=v」で画像の水平幅・
垂直幅の内部に仮引数「int x,int y」の値がＸＹ座標とし
ハミダシ不正を検査し、不正が有れば「return(STI_FLG);」
でエラーコードを返し関数終了！
「if(w==1){BYTE*p=(BYTE*)adr+x+y*inc;return(p);}」
は、条件「w==1」で画素の単位が１バイト単位を示し、
対応する分岐中身は、
「BYTE*p=(BYTE*)adr+x+y*inc;return(p);」と
「BYTE*p=(BYTE*)adr+x+y*inc;」で目的画素の
アドレス（ポインタ）を算出≪ローカル変数「BYTE*p」の
初期化として記述≫し、「return(*p);」と画素の値を
関数の値として返し終了！
「}elseif(w==2){shortp=(short*)adr+x+y*inc;
return(*p);}」は、条件「w==2」で画素の単位が
２バイト単位≪ここでは整数型「short型」≫を示し、
対応する分岐中身は、「short*p=(short*)adr+x+y*inc;
return(*p);」で目的画素のアドレス（ポインタ）を算出
≪ローカル変数「short*p」の初期化として記述≫し、
「return(p);」と画素の値を関数の値として返し終了！
「}elseif(w==4){int*p=(int*)adr+x+y*inc;
return(*p);}」は、条件「w==4」で画素の単位が４バイト
単位≪ここでは整数型「int型」≫を示し、対応する分岐
中身は、「int*p=(int*)adr+x+y*inc;
return(*p);」で目的画素のアドレス（ポインタ）を算出≪
ローカル変数「int*p」の初期化として記述≫し、
「return(*p);」と画素の値を関数の値として返し終了！
「}elseif(w==101){float*p=(float*)adr+x+y*inc;
return(*p);}」は、条件「w==101」で画素の単位が
４バイト単位≪ここでは単精度浮動小数点数型「float型」
≫を示し、対応する分岐中身は、
「float*p=(float*)adr+x+y*inc;return(*p);」で目的
画素のアドレス（ポインタ）を算出≪ローカル変数
「float*p」の初期化として記述≫し、「return(*p);」と
画素の値を関数の値として返し終了！
「}elseif(w==102){double*p=(double*)adr+x+y*inc;
return(*p);}」は、条件「w==102」で画素の単位が
８バイト単位≪ここでは倍精度浮動小数点
数型「double型」≫を示し、対応する分岐中身は、
「double*p=(double*)adr+x+y*inc;return(*p);」で
目的画素のアドレス（ポインタ）を算出≪ローカル変数
「double*p」の初期化として記述≫し、「return(*p);」と
画素の値を関数の値として返し終了！
「}else{return(STI_FLG);}」は、クラス「TypeArray」の
処理幅（1/2/4BYTE,101:単精度,102:倍精度）が指定外の
場合は、エラーコード「STI_FLG」の値を関数の値として
返し終了！
★注意★この関数「int get(int x,int y);」は、整数型の
値を関数の値として返します、
実数型（float型・double型）の場合は、整数値に
Ｃ言語標準の方式で丸められて値に成ります！
（２－５－２）関数「double getReal(int x,int y);」
double TypeArray::getReal(
int x, // 始点ｘ座標
int y // 始点ｙ座標
){
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v ){ // アドレスや座標が不正
return( STI_FLG ); // なら、不正を返す
} //
if( w == 1 ){ // １ＢＹＴＥなら
BYTE* p = (BYTE*)adr + x + y * inc; // 左記でポイント演算
return( (double)*p ); // ポインタで指す値を返す
}else if( w == 2 ){ // ２ＢＹＴＥなら
short* p = (short*)adr + x + y * inc; // 左記でポイント演算
return( (double)*p ); // ポインタで指す値を返す
}else if( w == 4 ){ // ４ＢＹＴＥなら
int* p = (int*)adr + x + y * inc; // 左記でポイント演算
return( (double)*p ); // ポインタで指す値を返す
}else if( w == 101 ){ // 単精度なら
float* p = (float*)adr + x + y * inc; // 左記でポイント演算
return( (double)*p ); // ポインタで指す値を返す
}else if( w == 102 ){ // 倍精度なら
double* p = (double*)adr + x + y * inc; // 左記でポイント演算
return( *p ); // ポインタで指す値を返す
}else{ // その他なら
return( STI_FLG ); // 不正を返す
} //
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－５－２－Ａ）関数名「double getReal(int x,int y);
」
「get」は、ゲット、日本語でも取得するを意味する用語
として今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素を取り出す事を意味
します！
「Real」は、実数値、この関数自体のリターン値は、
「double型」と倍精度浮動小数点実数値とＣ言語標準
実数値で返します！
（２－５－２－Ｂ）関数「getReal();」【仮引数】
double TypeArray::getReal(
int x, // 始点ｘ座標
int y // 始点ｙ座標
){「int x,」は、元の画像のＸ座標です！
「int y,」は、元の画像のＹ座標です！
（２－５－２－Ｃ）関数「getReal();」【アルゴリズム】
){
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v ){ // アドレスや座標が不正
return( STI_FLG ); // なら、不正を返す
} //
if( w == 1 ){ // １ＢＹＴＥなら
BYTE* p = (BYTE*)adr + x + y * inc; // 左記でポイント演算
return( (double)*p ); // ポインタで指す値を返す
}else if( w == 2 ){ // ２ＢＹＴＥなら
short* p = (short*)adr + x + y * inc; // 左記でポイント演算
return( (double)*p ); // ポインタで指す値を返す
}else if( w == 4 ){ // ４ＢＹＴＥなら
int* p = (int*)adr + x + y * inc; // 左記でポイント演算
return( (double)*p ); // ポインタで指す値を返す
}else if( w == 101 ){ // 単精度なら
float* p = (float*)adr + x + y * inc; // 左記でポイント演算
return( (double)*p ); // ポインタで指す値を返す
}else if( w == 102 ){ // 倍精度なら
double* p = (double*)adr + x + y * inc; // 左記でポイント演算
return( *p ); // ポインタで指す値を返す
}else{ // その他なら
return( STI_FLG ); // 不正を返す
} //
}「if(adr<=0||x<0||x>=h||y<0||y>=v){return(STI_FLG);}
」は、条件「adr<=0||x<0||x>=h||y<0||y>=v」で
「adr<=0」で画像が不正、「x<0||x>=h||y<0||y>=v」で
画像の水平幅・垂直幅の内部に仮引数「int x,int y」の
値がＸＹ座標としハミダシ不正を検査し、
不正が有れば「return(STI_FLG);」でエラーコードを返し
関数終了！
「if(w==1){BYTE*p=(BYTE*)adr+x+y*inc;return(*p);}」
は、条件「w==1」で画素の単位が１バイト単位を示し、
対応する分岐中身は、
「BYTE*p=(BYTE*)adr+x+y*inc;return(*p);」と
「BYTE*p=(BYTE*)adr+x+y*inc;」で目的画素のアドレス
（ポインタ）を算出≪ローカル変数「BYTE*p」の初期化と
して記述≫し、「return(*p);」と画素の値を関数の値とし
て返し終了！
「}else if(w==2){shortp=(short*)adr+x+yinc;
return(p);}」は、条件「w==2」で画素の単位が
２バイト単位≪ここでは整数型「short型」≫を示し、
対応する分岐中身は、「short*p=(short*)adr+x+y*inc;
return(*p);」で目的画素のアドレス（ポインタ）を算出≪
ローカル変数「short*p」の初期化として記述≫し、
「return(*p);」と画素の値を関数の値として返し終了！
「}else if(w==4){int*p=(int*)adr+x+y*inc;return(*p);}」
は、条件「w==4」で画素の単位が４バイト単位≪
ここでは整数型「int型」≫を示し、対応する分岐中身は、
「int*p=(int*)adr+x+y*inc;return(*p);」で目的画素の
アドレス（ポインタ）を算出≪ローカル変数「int*p」の
初期化として記述≫し、「return(*p);」と画素の値を
関数の値として返し終了！
「}else if(w==101){float*p=(float*)adr+x+y*inc;
return(*p);}」は、条件「w==101」で画素の単位が
４バイト単位≪ここでは単精度浮動小数点数型「float型」
≫を示し、対応する分岐中身は、
「float*p=(float*)adr+x+y*inc;return(*p);」で
目的画素のアドレス（ポインタ）を算出≪ローカル変数
「float*p」の初期化として記述≫し、「return(*p);」と
画素の値を関数の値として返し終了！
「}else if(w==102){double*p=(double)adr+x+y*inc;
return(*p);}」は、条件「w==102」で画素の単位が
８バイト単位≪ここでは倍精度浮動小数点数型
「double型」≫を示し、対応する分岐中身は、
「double*p=(double*)adr+x+y*inc;return(*p);」で
目的画素のアドレス（ポインタ）を算出≪ローカル変数
「double*p」の初期化として記述≫し、「return(*p);」と
画素の値を関数の値として返し終了！
「}else{return(STI_FLG);}」は、クラス「TypeArray」の
処理幅（1/2/4BYTE,101:単精度,102:倍精度）が指定外の
場合は、エラーコード「STI_FLG」の値を関数の値として
返し終了！
★注意★この関数「double getReal(int x,int y);」は、
実数型の値を関数の値として返します、実数型（float型・
double型）の場合は、倍精度浮動小数点数に精度が上がる
だけですが、整数値に対しては、Ｃ言語標準の方式で変換
された値に成ります！
（２－５－３）関数「void put(int x,int y,int d);」
void TypeArray::put(
int x, // 始点ｘ座標
int y, // 始点ｙ座標
int d // データ
){
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v ){ // アドレスや座標が不正
return; // なら終了
} //
if( w == 1 ){ // １ＢＹＴＥなら
BYTE* p = (BYTE*)adr + x + y * inc; // 左記でポイント演算
*p = d; // ポインタで指す値を返す
}else if( w == 2 ){ // ２ＢＹＴＥなら
short* p = (short*)adr + x + y * inc; // 左記でポイント演算
*p = d; // ポインタで指す値を返す
}else if( w == 4 ){ // ４ＢＹＴＥなら
int* p = (int*)adr + x + y * inc; // 左記でポイント演算
*p = d; // ポインタで指す値を返す
}else if( w == 101 ){ // 単精度なら
float* p = (float*)adr + x + y * inc; // 左記でポイント演算
*p = (float)d; // ポインタで指す値を返す
}else if( w == 102 ){ // 倍精度なら
double* p = (double*)adr + x + y * inc; // 左記でポイント演算
*p = d; // ポインタで指す値を返す
}else{ // その他なら
return; // 終了
} //
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－５－３－Ａ）関数名「void put(int x,int y,
int d);」
「put」は、プット、日本語でも「物などを場所に置く」を
意味する用語として今は、認知されている筈ですね！
ここでは、数値データを元の画像の任意の１画素の部分へ
セットする事を意味します！
（２－５－３－Ｂ）関数「put();」【仮引数】
void TypeArray::put(
int x, // 始点ｘ座標
int y, // 始点ｙ座標
int d // データ
){「int x,」は、元の画像のＸ座標です！
「int y,」は、元の画像のＹ座標です！
「int d」は、画素の値として書き込むデータで整数値
データです！
★注意★「void put(int x,int y,double d);」とオーバー
ローディング（多重定義）して居る事に注目！
「int d」で区別しています！
（２－５－３－Ｃ）関数「put();」【アルゴリズム】
){
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v ){ // アドレスや座標が不正
return; // なら終了
} //
if( w == 1 ){ // １ＢＹＴＥなら
BYTE* p = (BYTE*)adr + x + y * inc; // 左記でポイント演算
*p = d; // ポインタで指す値を返す
}else if( w == 2 ){ // ２ＢＹＴＥなら
short* p = (short*)adr + x + y * inc; // 左記でポイント演算
*p = d; // ポインタで指す値を返す
}else if( w == 4 ){ // ４ＢＹＴＥなら
int* p = (int*)adr + x + y * inc; // 左記でポイント演算
*p = d; // ポインタで指す値を返す
}else if( w == 101 ){ // 単精度なら
float* p = (float*)adr + x + y * inc; // 左記でポイント演算
*p = (float)d; // ポインタで指す値を返す
}else if( w == 102 ){ // 倍精度なら
double* p = (double*)adr + x + y * inc; // 左記でポイント演算
*p = d; // ポインタで指す値を返す
}else{ // その他なら
return; // 終了
} //
}「if(adr<=0||x<0||x>=h||y<0||y>=v){return(STI_FLG);}」
は、条件「adr<=0||x<0||x>=h||y<0||y>=v」で「adr<=0」
で画像が不正、「x<0||x>=h||y<0||y>=v」で画像の
水平幅・垂直幅の内部に仮引数「int x,int y」の値が
ＸＹ座標としハミダシ不正を検査し、不正が有れば
「return(STI_FLG);」でエラーコードを返し関数終了！
「if(w==1){BYTE*p=(BYTE*)adr+x+y*inc;*p=d;}」は、
条件「w==1」で画素の単位が１バイト単位を示し、
対応する分岐中身は、
「BYTE*p=(BYTE*)adr+x+y*inc;p=d;」と
「BYTE*p=(BYTE*)adr+x+y*inc;」で目的画素の
アドレス（ポインタ）を算出≪ローカル変数「BYTE*p」の
初期化として記述≫し、「*p=d;」とデータを画素の値とし
て書き込みます！★注意★下位１バイトデータが画素に書き
込まれます！
「}else if(w==2){short*p=(short*)adr+x+y*inc;*p=d;}」
は、条件「w==2」で画素の単位が２バイト単位≪
ここでは整数型「short型」≫を示し、対応する分岐中身は
「short*p=(short*)adr+x+y*inc;*p=d;」データが画素に
書き込まれます！目的画素のアドレス（ポインタ）を算出
≪ローカル変数「short*p」の初期化として記述≫し、
「*p=d;」とデータを画素の値として書き込みます！
★注意★下位２バイトデータが画素に書き込まれます！
「}else if(w==4){int*p=(int*)adr+x+y*inc;*p=d;}」は、
条件「w==4」で画素の単位が４バイト単位≪ここでは
整数型「int型」≫を示し、対応する分岐中身は、
「int*p=(int*)adr+x+y*inc;*p=d;」データが画素に書き
込まれます！目的画素のアドレス（ポインタ）を算出≪
ローカル変数「int*p」の初期化として記述≫し、
「p=d;」とデータを画素の値として書き込みます！
「}else if(w==101){float*p=(float*)adr+x+y*inc;*p=d;}」
は、条件「w==101」で画素の単位が４バイト単位≪
ここでは単精度浮動小数点数型「float型」≫を示し、
対応する分岐中身は、
「float*p=(float*)adr+x+y*inc;*p=(float)d;」で
目的画素のアドレス（ポインタ）を算出≪ローカル変数
「float*p」の初期化として記述≫し、
「*p=(float)d;」とデータを画素の値として書き込みます！
★注意★
勿論、キャスト演算「(float)d」と型変換で単精度浮動
小数点数値に変換して格納します！
「}else if(w==102){double*p=(double*)adr+x+y*inc;*p=d;}
」は、条件「w==102」で画素の単位が８バイト単位≪
ここでは倍精度浮動小数点数型「double型」≫を示し、
対応する分岐中身は、
「double*p=(double*)adr+x+y*inc;*p=d;」で目的画素の
アドレス（ポインタ）を算出≪ローカル変数「double*p」
の初期化として記述≫し、「*p=d;」とデータを画素の値と
して書き込みます！★注意★
勿論、Ｃ言語標準の型変換で単倍精度浮動小数点数値に
変換して格納します！
「}else{return;}」は、クラス「TypeArray」の処理幅（
1/2/4BYTE,101:単精度,102:倍精度）が指定外の場合は、
何もセズに単に終了！
（２－５－４）関数「void put(int x,int y,double d);」
void TypeArray::put(
int x, // 始点ｘ座標
int y, // 始点ｙ座標
double d // データ
){
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v ){ // アドレスや座標が不正
return; // なら終了
} //
if( w == 1 ){ // １ＢＹＴＥなら
BYTE* p = (BYTE*)adr + x + y * inc; // 左記でポイント演算
*p = (BYTE)d; // ポインタで指す値を返す
}else if( w == 2 ){ // ２ＢＹＴＥなら
short* p = (short*)adr + x + y * inc; // 左記でポイント演算
*p = (short)d; // ポインタで指す値を返す
}else if( w == 4 ){ // ４ＢＹＴＥなら
int* p = (int*)adr + x + y * inc; // 左記でポイント演算
*p = (int)d; // ポインタで指す値を返す
}else if( w == 101 ){ // 単精度なら
float* p = (float*)adr + x + y * inc; // 左記でポイント演算
*p = (float)d; // ポインタで指す値を返す
}else if( w == 102 ){ // 倍精度なら
double* p = (double*)adr + x + y * inc; // 左記でポイント演算
*p = d; // ポインタで指す値を返す
}else{ // その他なら
return; // 終了
} //
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－５－４－Ａ）関数名「void put();」
「put」は、プット、日本語でも「物などを場所に置く」を
意味する用語として今は、認知されている筈ですね！
ここでは、数値データを元の画像の任意の１画素の部分へ
セットする事を意味します！
（２－５－４－Ｂ）関数「put();」【仮引数】
void TypeArray::put(
int x, // 始点ｘ座標
int y, // 始点ｙ座標
double d // データ
){「int x,」は、元の画像のＸ座標です！
「int y,」は、元の画像のＹ座標です！
「double d」は、画素の値として書き込むデータで
倍精度浮動小数点数値データです！
★注意★「void put(int x,int y,int d);」とオーバー
ローディング（多重定義）して居る事に注目！
「double d」で区別しています！
（２－５－４－Ｃ）関数「put();」【アルゴリズム】
){
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v ){ // アドレスや座標が不正
return; // なら終了
} //
if( w == 1 ){ // １ＢＹＴＥなら
BYTE* p = (BYTE*)adr + x + y * inc; // 左記でポイント演算
*p = (BYTE)d; // ポインタで指す値を返す
}else if( w == 2 ){ // ２ＢＹＴＥなら
short* p = (short*)adr + x + y * inc; // 左記でポイント演算
*p = (short)d; // ポインタで指す値を返す
}else if( w == 4 ){ // ４ＢＹＴＥなら
int* p = (int*)adr + x + y * inc; // 左記でポイント演算
*p = (int)d; // ポインタで指す値を返す
}else if( w == 101 ){ // 単精度なら
float* p = (float*)adr + x + y * inc; // 左記でポイント演算
*p = (float)d; // ポインタで指す値を返す
}else if( w == 102 ){ // 倍精度なら
double* p = (double*)adr + x + y * inc; // 左記でポイント演算
*p = d; // ポインタで指す値を返す
}else{ // その他なら
return; // 終了
} //
}「if(adr<=0||x<0||x>=h||y<0||y>=v){
return(STI_FLG);}」は、
条件「adr<=0||x<0||x>=h||y<0||y>=v」で「adr<=0」で
画像が不正、「x<0||x>=h||y<0||y>=v」で画像の水平幅・
垂直幅の内部に仮引数「int x,int y」の値がＸＹ座標とし
ハミダシ不正を検査し、不正が有れば「return(STI_FLG);」
でエラーコードを返し関数終了！
「if(w==1){BYTE*p=(BYTE*)adr+x+y*inc;p=(BYTE*)d;}」
は、条件「w==1」で画素の単位が１バイト単位を示し、
対応する分岐中身は、
「BYTE*p=(BYTE*)adr+x+y*inc;*p=(BYTE)d;」と
「BYTE*p=(BYTE*)adr+x+y*inc;」で目的画素のアドレス
（ポインタ）を算出≪ローカル変数「BYTE*p」の初期化と
して記述≫し、「*p=(BYTE)d;」とデータを画素の値として
書き込みます！★注意★元々の倍精度浮動小数点数値を
一旦、キャスト演算（(BYTE)d）と整数化して丸めて
下位１バイトデータが画素に書き込まれます！
「}else if(w==2){short*p=(short*)adr+x+y*inc;
*p=(short)d;}」は、条件「w==2」で画素の単位が
２バイト単位≪ここでは整数型「short型」≫を示し、
対応する分岐中身は、「short*p=(short*)adr+x+y*inc;
*p=(short)d;」とデータが画素に書き込まれます！
目的画素のアドレス（ポインタ）を算出≪ローカル変数
「short*p」の初期化として記述≫し、
「*p=(short)d;」とデータを画素の値として書き込み
ます！★注意★
下位２バイトデータが画素に書き込まれます！
「}else if(w==4){int*p=(int*)adr+x+y*inc;
*p=(int)d;}」は、条件「w==4」で画素の単位が
４バイト単位≪ここでは整数型「int型」≫を示し、
対応する分岐中身は、「int*p=(int*)adr+x+y*inc;
p=(int)d;」とデータが画素に書き込まれます！
目的画素のアドレス（ポインタ）を算出≪
ローカル変数「int*p」の初期化として記述≫し、
「p=(int*)d;」とデータを画素の値として書き込みます！
「}else if(w==101){float*p=(float*)adr+x+y*inc;
p=(float)d;}」は、条件「w==101」で画素の単位が
４バイト単位≪ここでは単精度浮動小数点数型「float型」
≫を示し、対応する分岐中身は、
「float*p=(float*)adr+x+y*inc;p=(float)d;」で
目的画素のアドレス（ポインタ）を算出≪ローカル変数
「float*p」の初期化として記述≫し、「*p=(float)d;」と
データを画素の値として書き込みます！
★注意★勿論、キャスト演算「(float)d」と型変換で
倍精度から単精度浮動小数点数値に変換して格納します！
「}else if(w==102){double*p=(double*)adr+x+y*inc;
*p=(double)d;}」は、条件「w==102」で画素の単位が
８バイト単位≪ここでは倍精度浮動小数点数型「double型」
≫を示し、対応する分岐中身は、
「double*p=(double*)adr+x+y*inc;p=(double)d;」で
目的画素のアドレス（ポインタ）を算出≪ローカル変数
「double*p」の初期化として記述≫し、「*p=(double)d;」
とデータを画素の値として書き込みます！
★注意★勿論、倍精度から倍精度へ変換して居るので無意味
な記載ですがエディタ操作時に面倒だからソノママにして
居ます！
「}else{return;}」は、クラス「TypeArray」の処理幅（
1/2/4BYTE,101:単精度,102:倍精度）が指定外の場合は、
何もセズに単に終了！
★注意★
勿論、「put(int x,inta y,int d);」と
「put(int x,inta y,double d);」は、書き込みデータが
整数型と倍精度浮動小数点データと違うので多重定義（
オーバーロード）ですが、意味は同じです！
（２－５－５）関数「int getDataInt(int x,int y);」
int TypeArray::getDataInt(
int x, // 始点ｘ座標
int y // 始点ｙ座標
){
BYTE* pB; // １バイト単位整数ポインタ
short* pS; // ２バイト単位整数ポインタ
int* pI; // ４バイト単位整数ポインタ
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v // アドレスや座標が不正か
|| w > 4 ){ // 整数以外なら
return( STI_FLG ); // 不正を返す
} //
if( w == 1 ){ // １ＢＹＴＥなら
if( x + 4 >= h ){ // 格納場所違反なら
return( STI_FLG ); // 不正を返す
} //
pB = (BYTE*)adr + x + y * inc; // 左記でポイント演算
pI = (int*)pB; // ４バイト整数アクセスへ
return( *pI ); // ポインタで指す値を返す
}else if( w == 2 ){ // ２ＢＹＴＥなら
if( x + 2 >= h ){ // 格納場所違反なら
return( STI_FLG ); // 不正を返す
} //
pS = (short*)adr + x + y * inc; // 左記でポイント演算
pI = (int*)pS; // ４バイト整数アクセスへ
return( *pI ); // ポインタで指す値を返す
}else if( w == 4 ){ // ４ＢＹＴＥなら
pI = (int*)adr + x + y * inc; // 左記でポイント演算
return( *pI ); // ポインタで指す値を返す
}else{ // その他なら
return( STI_FLG ); // 不正を返す
} //
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－５－５－Ａ）関数名「int getDataInt(
int x,int y);」
「get」は、ゲット、日本語でも取得するを意味する用語
として今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素を取り出す事を意味
します！
「Data」は、データで
「Int」は、「int型」≪４バイト整数型≫です！
機能としては、整数型の画素単位≪クラス「TypeArray」の
処理幅（1/2/4BYTE,101:単精度,102:倍精度）≫が、
整数「1/2/4BYTE」の画像メモリから「int型」の整数値を
取り出す事です！
（２－５－５－Ｂ）関数「getDataInt();」【仮引数】
int TypeArray::getDataInt(
int x, // 始点ｘ座標
int y // 始点ｙ座標
){「int x,」は、元の画像のＸ座標です！
「int y,」は、元の画像のＹ座標です！
（２－５－５－Ｃ）関数「getDataInt();」【ローカル変数】
BYTE* pB; // １バイト単位整数ポインタ
short* pS; // ２バイト単位整数ポインタ
int* pI; // ４バイト単位整数ポインタ「BYTE* pB;」は、１バイト単位の整数型ポインタです！
「short* pS;」は、２バイト単位の整数型ポインタです！
「int* pI;」は、４バイト単位の整数型ポインタです！
（２－５－５－Ｄ）関数「getDataInt();」【アルゴリズム】
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v // アドレスや座標が不正か
|| w > 4 ){ // 整数以外なら
return( STI_FLG ); // 不正を返す
} //
if( w == 1 ){ // １ＢＹＴＥなら
if( x + 4 >= h ){ // 格納場所違反なら
return( STI_FLG ); // 不正を返す
} //
pB = (BYTE*)adr + x + y * inc; // 左記でポイント演算
pI = (int*)pB; // ４バイト整数アクセスへ
return( *pI ); // ポインタで指す値を返す
}else if( w == 2 ){ // ２ＢＹＴＥなら
if( x + 2 >= h ){ // 格納場所違反なら
return( STI_FLG ); // 不正を返す
} //
pS = (short*)adr + x + y * inc; // 左記でポイント演算
pI = (int*)pS; // ４バイト整数アクセスへ
return( *pI ); // ポインタで指す値を返す
}else if( w == 4 ){ // ４ＢＹＴＥなら
pI = (int*)adr + x + y * inc; // 左記でポイント演算
return( *pI ); // ポインタで指す値を返す
}else{ // その他なら
return( STI_FLG ); // 不正を返す
} //
}「if(adr<=0||x<0||x>=h||y<0||y>=v||w>4){
return(STI_FLG);}」は、
条件「adr<=0||x<0||x>=h||y<0||y>=v」で「adr<=0」で
画像が不正、「x<0||x>=h||y<0||y>=v」で画像の水平幅・
垂直幅の内部に仮引数「int x,int y」の値がＸＹ座標とし
ハミダシ不正を検査し、
更に「w>4」で画素単位が整数型で無い事を検査し、
不正が有れば、「return(STI_FLG);」でエラーコードを返し
関数終了！
「if(w==1){・・条件成立・・}」は、条件「w==1」で画素の
単位が１バイト単位を示し、対応する
「if(x+4>=h){return(STI_FLG);}
pB=(BYTE*)adr+x+y*inc;pI=(int*)pB;return(*pI);}」と
内側の「if(x+4>=h){return(STI_FLG);}」と条件「x+4>=h」
と仮引数「int x,」の値で示されたＸ座標から「int型」
詰り４バイト幅のデータが水平幅の範囲内に収まら無かった
ら、内側の成立中身「return(STI_FLG);」でエラーコード
「STI_FLG」を関数の値として終了！
「pB=(BYTE*)adr+x+y*inc」は、バイト単位画素の指定
ポインタ算出！
「pI=(int*)pB」は、キャスト演算でポインタを「int型」
に変換！
「return(*pI);」は、ポインタ「int型」でアクセスして、
その４バイト整数値を関数の値として返し終了！
「}else if(w==2){・・条件成立・・}」は、
条件「w==2」で画素の単位が２バイト単位を示し、
対応する「if(x+2>=h){return(STI_FLG);}
pS=(short*)adr+x+y*inc;pI=(int*)pS;return(*pI);}」と
内側の「if(x+2>=h){return(STI_FLG);}」と
条件「x+2>=h」と仮引数「int x,」の値で示されたＸ座標
から「int型」詰り４バイト幅（short型の二つ分）の
データが水平幅の範囲内に収まら無かったら、内側の成立
中身「return(STI_FLG);」でエラーコード「STI_FLG」を
関数の値として終了！
「pS=(short*)adr+x+y*inc」は、「short型」２バイト
単位画素の指定ポインタ算出！
「pI=(int*)pS」は、キャスト演算でポインタを「int型」
に変換！
「return(*pI);」は、ポインタ「int型」でアクセスして、
その４バイト整数値を関数の値として返し終了！
「}else if(w==4){・・条件成立・・}」は、
条件「w==4」で画素の単位が４バイト単位を示し、
対応する中身「pI=(int*)adr+x+y*inc;return(*pI);}」と
「pI=(short*)adr+x+y*inc」は、「int型」４バイト単位
画素の指定ポインタ算出！
「return(*pI);」は、ポインタ「int型」でアクセスして、
その４バイト整数値を関数の値として返し終了！
「}else{」は、クラス「TypeArray型」を正規の方法
（Malloc()系・SetByte()等）でセットされた画素単位
「w」の指定されている事を意味するので
「return(STI_FLG);」でエラーコード「STI_FLG」を関数の
値として終了！
★備考★「Ｎｏｔｅ投稿用エディタで変な特徴」≪
半角「*」がコピペしてＰＣ上のテキストファイルから
ペーストする時に消える場合が在る！今回、良く起こった
のは「y*orgPtr->inc」と乗算が消え「yorgPtr->inc」
との表現や、仮引数「TypeArray* orgPtr,」が
「TypeArray orgPtr,」≫と成り、手作業で編集を一文字
づつ行った事です！恐らく、Ｃｏｄｅ機能でソースコード
を表示して居る所は、変な事が起きずに表示して居ると思
いますので本文で変な所が有れば、見比べて確認して
下さい！見落としが、残って居る可能性が有ります！
更に見落としとし「else if」との記載を、「空白」が
投稿用エディタで消され「elseif」と成る場合が有るので
Ｃｏｄｅ機能でソースコードを表示して居る方が正しいと
考えて下さい！因みに「Ｃ言語」で無く「Ａｄａ」の様な
言語では「elseif」は、正規のキーワードです！
取り敢えず、今日は、ココまで疲れた？！また、
これは近々続きの講義を始めますのでココまでは、
理解して下さい！！
２０２４年１月３１継続講義
（２－５－６）関数「int getDataShort(
int x,int y);」
int TypeArray::getDataShort(
int x, // 始点ｘ座標
int y // 始点ｙ座標
){
BYTE* pB; // １バイト単位整数ポインタ
short* pS; // ２バイト単位整数ポインタ
int* pI; // ４バイト単位整数ポインタ
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v // アドレスや座標が不正か
|| w > 4 ){ // 整数以外なら
return( STI_FLG ); // 不正を返す
} //
if( w == 1 ){ // １ＢＹＴＥなら
if( x + 2 >= h ){ // 格納場所違反なら
return( STI_FLG ); // 不正を返す
} //
pB = (BYTE*)adr + x + y * inc; // 左記でポイント演算
pS = (short*)pB; // ２バイト整数アクセスへ
return( *pS ); // ポインタで指す値を返す
}else if( w == 2 ){ // ２ＢＹＴＥなら
pS = (short*)adr + x + y * inc; // 左記でポイント演算
return( *pS ); // ポインタで指す値を返す
}else if( w == 4 ){ // ４ＢＹＴＥなら
pI = (int*)adr + x + y * inc; // 左記でポイント演算
pS = (short*)pI; // ２バイト整数アクセスへ
return( *pS ); // ポインタで指す値を返す
}else{ // その他なら
return( STI_FLG ); // 不正を返す
} //
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－５－６－Ａ）関数名「int getDataShort(
int x,int y);」
「get」は、ゲット、日本語でも取得するを意味する用語と
して今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素を取り出す事を意味し
ます！
「Data」は、データで
「Short」は、「short型」≪２バイト整数型≫です！
機能としては、整数型の画素単位≪クラス「TypeArray」の
処理幅（1/2/4BYTE,101:単精度,102:倍精度）≫が、
整数「1/2/4BYTE」の画像メモリから「int型」の整数値を
取り出す事です！
（２－５－６－Ｂ）関数「getDataShort();」【仮引数】
int TypeArray::getDataShort(
int x, // 始点ｘ座標
int y // 始点ｙ座標
){「int x,」は、元の画像のＸ座標です！
「int y,」は、元の画像のＹ座標です！
（２－５－６－Ｃ）関数「getDataShort();」
【ローカル変数】
BYTE* pB; // １バイト単位整数ポインタ
short* pS; // ２バイト単位整数ポインタ
int* pI; // ４バイト単位整数ポインタ「BYTE* pB;」は、１バイト単位の整数型ポインタです！
「short* pS;」は、２バイト単位の整数型ポインタです！
「int* pI;」は、４バイト単位の整数型ポインタです！
（２－５－６－Ｄ）関数「getDataShort();」
【アルゴリズム】
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v // アドレスや座標が不正か
|| w > 4 ){ // 整数以外なら
return( STI_FLG ); // 不正を返す
} //
if( w == 1 ){ // １ＢＹＴＥなら
if( x + 2 >= h ){ // 格納場所違反なら
return( STI_FLG ); // 不正を返す
} //
pB = (BYTE*)adr + x + y * inc; // 左記でポイント演算
pS = (short*)pB; // ２バイト整数アクセスへ
return( *pS ); // ポインタで指す値を返す
}else if( w == 2 ){ // ２ＢＹＴＥなら
pS = (short*)adr + x + y * inc; // 左記でポイント演算
return( *pS ); // ポインタで指す値を返す
}else if( w == 4 ){ // ４ＢＹＴＥなら
pI = (int*)adr + x + y * inc; // 左記でポイント演算
pS = (short*)pI; // ２バイト整数アクセスへ
return( *pS ); // ポインタで指す値を返す
}else{ // その他なら
return( STI_FLG ); // 不正を返す
} //
}「if(adr<=0||x<0||x>=h||y<0||y>=v||w>4){
return(STI_FLG);}」は、
条件「adr<=0||x<0||x>=h||y<0||y>=v」で「adr<=0」で
画像が不正、「x<0||x>=h||y<0||y>=v」で画像の水平幅・
垂直幅の内部に仮引数「int x,int y」の値がＸＹ座標とし
ハミダシ不正を検査し、更に「w>4」で画素単位が整数型で
無い事を検査し、不正が有れば、
「return(STI_FLG);」でエラーコードを返し関数終了！
「if(w==1){・・条件成立・・}」は、条件「w==1」で
画素の単位が１バイト単位を示し、
対応する「if(x+2>=h){return(STI_FLG);}
pB=(BYTE*)adr+x+y*inc;pS=(short*)pB;return(*pS);}」と
内側の「if(x+2>=h){return(STI_FLG);}」と条件
「x+2>=h」と仮引数「int x,」の値で示されたＸ座標から
「short型」詰り２バイト幅のデータが水平幅の範囲内に
収まら無かったら、内側の成立中身「return(STI_FLG);」で
エラーコード「STI_FLG」を関数の値として終了！
「pB=(BYTE*)adr+x+yinc」は、バイト単位画素の指定
ポインタ算出！
「pS=(short*)pB」は、キャスト演算でポインタを
「short型」に変換！
「return(*pS);」は、ポインタ「short型」でアクセス
して、その２バイト整数値を関数の値として返し終了！
「}else if(w==2){・・条件成立・・}」は、
条件「w==2」で画素の単位が２バイト単位を示し、
対応する「pS=(short*)adr+x+y*inc;return(*pS);}」と
「pS=(short*)adr+x+y*inc」は、「short型」２バイト
単位画素の指定ポインタ算出！
「return(*pS);」は、ポインタ「short型」でアクセス
して、その４バイト整数値を関数の値として返し終了！
「}else if(w==4){・・条件成立・・}」は、
条件「w==4」で画素の単位が４バイト単位を示し、対応
する中身「pI=(int*)adr+x+y*inc;return(*pS);}」と
「pI=(int*)adr+x+y*inc」は、「int型」４バイト単位
画素の指定ポインタ算出！
「pS=(short*)pI;」は、キャスト演算でポインタを
「short*型」に変換！
「return(*pS);」は、ポインタ「short型」でアクセス
して、その２バイト整数値を関数の値として返し終了！
「}else{」は、クラス「TypeArray型」を正規の
方法（Malloc()系・SetByte()等）でセットされた画素
単位「w」の指定されている事を意味するので
「return(STI_FLG);」でエラーコード「STI_FLG」を関数の
値として終了！
（２－５－７）関数「void putDataInt(int x,int y,
int d);」
void TypeArray::putDataInt(
int x, // 始点ｘ座標
int y, // 始点ｙ座標
int d // データ
){
BYTE* pB; // １バイト単位整数ポインタ
short* pS; // ２バイト単位整数ポインタ
int* pI; // ４バイト単位整数ポインタ
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v // アドレスや座標が不正か
|| w > 4 ){ // 整数以外なら
return; // 終了
} //
if( w == 1 ){ // １ＢＹＴＥなら
if( x + 4 >= h ){ // 格納場所違反なら
return; // 終了
} //
pB = (BYTE*)adr + x + y * inc; // 左記でポイント演算
pI = (int*)pB; // ４バイト整数アクセスへ
*pI = d; // データ書き込み
}else if( w == 2 ){ // ２ＢＹＴＥなら
if( x + 2 >= h ){ // 格納場所違反なら
return; // 終了
} //
pS = (short*)adr + x + y * inc; // 左記でポイント演算
pI = (int*)pS; // ４バイト整数アクセスへ
*pI = d; // データ書き込み
}else if( w == 4 ){ // ４ＢＹＴＥなら
pI = (int*)adr + x + y * inc; // 左記でポイント演算
*pI = d; // データ書き込み
} //
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－５－７－Ａ）関数名「void putDataInt(
int x,int y,int d);」
「put」は、プット、日本語でも「物などを場所に置く」を
意味する用語として今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素へ書き込む事を意味
します！
「Data」は、データで
「Int」は、「int型」≪４バイト整数型≫です！
機能としては、整数型の画素単位≪クラス「TypeArray」の
処理幅（1/2/4BYTE,101:単精度,102:倍精度）≫が、
整数「1/2/4BYTE」の画像メモリから「int型」の整数値を
書き込む事です！
（２－５－７－Ｂ）関数「putDataInt();」【仮引数】
void TypeArray::putDataInt(
int x, // 始点ｘ座標
int y, // 始点ｙ座標
int d // データ
){「int x,」は、元の画像のＸ座標です！
「int y,」は、元の画像のＹ座標です！
「int d」は、画素の値として書き込むデータで整数値
データです！
（２－５－７－Ｃ）関数「putDataInt();」【ローカル変数】
){
BYTE* pB; // １バイト単位整数ポインタ
short* pS; // ２バイト単位整数ポインタ
int* pI; // ４バイト単位整数ポインタ「BYTE* pB;」は、１バイト単位の整数型ポインタです！
「short* pS;」は、２バイト単位の整数型ポインタです！
「int* pI;」は、４バイト単位の整数型ポインタです！
（２－５－７－Ｄ）関数「putDataInt();」【アルゴリズム】
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v // アドレスや座標が不正か
|| w > 4 ){ // 整数以外なら
return; // 終了
} //
if( w == 1 ){ // １ＢＹＴＥなら
if( x + 4 >= h ){ // 格納場所違反なら
return; // 終了
} //
pB = (BYTE*)adr + x + y * inc; // 左記でポイント演算
pI = (int*)pB; // ４バイト整数アクセスへ
*pI = d; // データ書き込み
}else if( w == 2 ){ // ２ＢＹＴＥなら
if( x + 2 >= h ){ // 格納場所違反なら
return; // 終了
} //
pS = (short*)adr + x + y * inc; // 左記でポイント演算
pI = (int*)pS; // ４バイト整数アクセスへ
*pI = d; // データ書き込み
}else if( w == 4 ){ // ４ＢＹＴＥなら
pI = (int*)adr + x + y * inc; // 左記でポイント演算
*pI = d; // データ書き込み
} //
}「if(adr<=0||x<0||x>=h||y<0||y>=v||w>4){return}」は、
条件「adr<=0||x<0||x>=h||y<0||y>=v」で「adr<=0」で
画像が不正、
「x<0||x>=h||y<0||y>=v」で画像の水平幅・垂直幅の
内部に仮引数「int x,int y」の値がＸＹ座標とし
ハミダシ不正を検査し、更に「w>4」で画素単位が整数型で
無い事を検査し、不正が有れば、「return;」で関数終了！
「if(w==1){・・条件成立・・}」は、条件「w==1」で
画素の単位が１バイト単位を示し、対応する
「if(x+4>=h){return;}
pB=(BYTE*)adr+x+y*inc;pI=(int*)pB;pI=d;return;}」と
内側の「if(x+4>=h){return}」と条件「x+4>=h」と
仮引数「int x,」の値で示されたＸ座標から「int型」
詰り４バイト幅のデータが水平幅の範囲内に収まら無かっ
たら、内側の成立中身「return;」で関数終了！
「pB=(BYTE*)adr+x+y*inc」は、バイト単位画素の
指定ポインタ算出！
「pI=(int*)pB」は、キャスト演算でポインタを「int型」
に変換！
「*pI=d;」で「int型」４バイト整数で画素に書き込み！
「return;」で関数終了！
「}else if(w==2){・・条件成立・・}」は、条件「w==2」
で画素の単位が２バイト単位を示し、
対応する「if(x+2>=h){return;}
pS=(short*)adr+x+y*inc;pI=(int*)pS;*pI=d;return;}」
と内側の「if(x+2>=h){return(STI_FLG);}」と
条件「x+2>=h」と仮引数「int x,」の値で示された
Ｘ座標から「int型」詰り４バイト幅（short型の二つ分）
のデータが水平幅の範囲内に収まら無かったら、
内側の成立中身「return;」で終了！
「pS=(short*)adr+x+y*inc」は、「short型」２バイト単位
画素の指定ポインタ算出！
「pI=(int*)pS」は、キャスト演算でポインタを
「int型」に変換！
「*pI=d;」で「int型」４バイト整数で画素に書き込み！
「return;」で関数終了！
「}else if(w==4){・・条件成立・・}」は、
条件「w==4」で画素の単位が４バイト単位を示し、
対応する中身「pI=(int*)adr+x+y*inc;
「*pI=d;」で「int型」４バイト整数で画素に書き込み！
「return;」で関数終了！
「}else{」は、クラス「TypeArray型」を正規の方法（
Malloc()系・SetByte()等）でセットされた画素単位「w」
の指定されている事を意味するので「return;」で
関数終了！
（２－５－８）関数「void putDataShort(
int x,int y,int d);」
void TypeArray::putDataShort(
int x, // 始点ｘ座標
int y, // 始点ｙ座標
int d // データ
){
BYTE* pB; // １バイト単位整数ポインタ
short* pS; // ２バイト単位整数ポインタ
int* pI; // ４バイト単位整数ポインタ
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v // アドレスや座標が不正か
|| w > 4 ){ // 整数以外なら
return; // 終了
} //
if( w == 1 ){ // １ＢＹＴＥなら
if( x + 2 >= h ){ // 格納場所違反なら
return; // 終了
} //
pB = (BYTE*)adr + x + y * inc; // 左記でポイント演算
pS = (short*)pB; // ２バイト整数アクセスへ
*pS = d; // データ書き込み
}else if( w == 2 ){ // ２ＢＹＴＥなら
pS = (short*)adr + x + y * inc; // 左記でポイント演算
*pS = d; // データ書き込み
}else if( w == 4 ){ // ４ＢＹＴＥなら
pI = (int*)adr + x + y * inc; // 左記でポイント演算
pS = (short*)pI; // ２バイト整数アクセスへ
*pS = d; // データ書き込み
} //
}因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－５－８－Ａ）関数名「void putDataShort(
int x,int y,int d);」
「put」は、プット、日本語でも「物などを場所に置く」を
意味する用語として今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素へ書き込む事を意味
します！
「Data」は、データで
「Short」は、「short型」≪２バイト整数型≫です！
機能としては、整数型の画素単位≪クラス「TypeArray」の
処理幅（1/2/4BYTE,101:単精度,102:倍精度）≫が、
整数「1/2/4BYTE」の画像メモリから「short型」の
整数値を書き込む事です！
（２－５－８－Ｂ）関数「putDataShort();」【仮引数】
void TypeArray::putDataShort(
int x, // 始点ｘ座標
int y, // 始点ｙ座標
int d // データ
){「int x,」は、元の画像のＸ座標です！
「int y,」は、元の画像のＹ座標です！
「int d」は、画素の値として書き込むデータで整数値
データです！
（２－５－８－Ｃ）関数「putDataShort();」
【ローカル変数】
BYTE* pB; // １バイト単位整数ポインタ
short* pS; // ２バイト単位整数ポインタ
int* pI; // ４バイト単位整数ポインタ「BYTE* pB;」は、１バイト単位の整数型ポインタです！
「short* pS;」は、２バイト単位の整数型ポインタです！
「int* pI;」は、４バイト単位の整数型ポインタです！
（２－５－８－Ｄ）関数「putDataShort();」
【アルゴリズム】
if( adr <= 0 || x < 0 || x >= h || y < 0 || y >= v // アドレスや座標が不正か
|| w > 4 ){ // 整数以外なら
return; // 終了
} //
if( w == 1 ){ // １ＢＹＴＥなら
if( x + 2 >= h ){ // 格納場所違反なら
return; // 終了
} //
pB = (BYTE*)adr + x + y * inc; // 左記でポイント演算
pS = (short*)pB; // ２バイト整数アクセスへ
*pS = d; // データ書き込み
}else if( w == 2 ){ // ２ＢＹＴＥなら
pS = (short*)adr + x + y * inc; // 左記でポイント演算
*pS = d; // データ書き込み
}else if( w == 4 ){ // ４ＢＹＴＥなら
pI = (int*)adr + x + y * inc; // 左記でポイント演算
pS = (short*)pI; // ２バイト整数アクセスへ
*pS = d; // データ書き込み
} //
}「if(adr<=0||x<0||x>=h||y<0||y>=v||w>4){return}」は、
条件「adr<=0||x<0||x>=h||y<0||y>=v」で「adr<=0」で
画像が不正、「x<0||x>=h||y<0||y>=v」で画像の水平幅・
垂直幅の内部に仮引数「int x,int y」の値がＸＹ座標とし
ハミダシ不正を検査し、更に「w>4」で画素単位が整数型で
無い事を検査し、不正が有れば、「return;」で関数終了！
「if(w==1){・・条件成立・・}」は、条件「w==1」で
画素の単位が１バイト単位を示し、
対応する「if(x+2>=h){return;}
pB=(BYTE*)adr+x+y*inc;pS=(short*)pB;*pS=d;return;}」と
内側の「if(x+2>=h){return}」と条件「x+2>=h」と
仮引数「int x,」の値で示されたＸ座標から「short型」詰り２バイト幅の
データが水平幅の範囲内に収まら無かったら、内側の成立中身「return;」
で関数終了！
「pB=(BYTE*)adr+x+y*inc」は、バイト単位画素の指定
ポインタ算出！
「pS=(short*)pB」は、キャスト演算でポインタを
「short型」に変換！
「*pS=d;」で「short型」２バイト整数で画素に書き込み！
「return;」で関数終了！
「}else if(w==2){・・条件成立・・}」は、条件「w==2」で
画素の単位が２バイト単位を示し、
対応する「if(x+2>=h){return(STI_FLG);}
pS=(short*)adr+x+y*inc;*pS=d;return;}」と
内側の「if(x+2>=h){return(STI_FLG);}」と
条件「x+2>=h」と仮引数「int x,」の値で示されたＸ座標
から「short型」詰り２バイト幅（short型）のデータが
水平幅の範囲内に収まら無かったら、内側の成立中身
「return;」で終了！
「pS=(short*)adr+x+y*inc」は、「short型」２バイト単位
画素の指定ポインタ算出！
「pS=d;」で「short型」２バイト整数で画素に書き込み！
「return;」で関数終了！
「}else if(w==4){・・条件成立・・}」は、
条件「w==4」で画素の単位が４バイト単位を示し、
対応する中身「pI=(int*)adr+x+y*inc;
pS=(short*)pI;*pS=d;return;
「pS=(short*)pB」は、キャスト演算でポインタを
「short*型」に変換！
「*pS=d;」で「short型」２バイト整数で画素に書き込み！
「return;」で関数終了！
「}else{」は、クラス「TypeArray型」を正規の方法
（Malloc()系・SetByte()等）でセットされた画素単位「w」
の指定されている事を意味するので「return;」で
関数終了！
（２－６）メンバー変数
public: // 構造体の内部変数（画像サイズ＆画素型）
int adr; // アドレス
int h; // 水平方向大きさ（実範囲）
int v; // 垂直大きさ
int inc; // 水平方向大きさ(垂直増加用)0:１次
char w; // 処理幅（1/2/4BYTE,101:単精度,102:倍精度）
public: // inline 関数「public:」は、メンバー変数もパブリック属性にして
外からアクセス可能です！
★注意★勿論、このクラス「TypeArray」を高速に使用する
為の方策ですが、読者様が直接、アクセスするアプリを
作成した場合は、ドウナルカは、私（作者）としては、
保証しかねます！！
「int adr;」は、画像メモリのアドレス≪物理的な半導体
メモリーの機械アドレスとか仮想記憶システムの
システムが提供したアドレス≫を示します
★注意★元々、ＡＤＳ社の画像処理装置のＣＰＵはＺ８０と
言う８ビットのＣＰＵで機械語（アセンブラ表現）で
コンピュータープログラミングしていた名残として
１６ビットＣＰＵ≪ＭＣ６８Ｋ≫から使える様に成った
Ｃ言語でもポインタで無く機械アドレスとイメージを
踏襲したから、其れをＣ＋＋まで継承して使って居るから
です！
「int h; 」は、画像メモリの水平幅です！
「int v; 」は、画像メモリの垂直幅です！
「int inc;」は、画像メモリの増加幅です！
「char w;」は、画素の処理幅≪１・２・４バイトと整数値
画素を示す値
１０１：単精度浮動小数点数値４バイトサイズ・
１０２：倍精度浮動小数点数値８バイトサイズ≫
★注意★「int h;int v;int inc;」と「○○幅」と画像の
幅に関しては、「int型」でこの「char w;」が、
「char型」なのは、出来るだけコンパクトに
コンピューターシステム上に現れる様にした為です！
☆備考☆
多くのシステムで「メモリアクセスのバウンダリ」として
４の倍数特に１６バイトは意味を持ちますので
「int h;int v;int inc;」までで１２バイト、
「int h;int v;int inc;char w;」と単純には１３バイト
ですが、実際のシステムでは、
「メモリアクセスのバウンダリ」に依って１６バイト物理的
な半導体メモリー＆仮想記憶システムのシステムが提供し
たメモリの割付が行われ「char w;」でも「int w;」でも
変わりが無い事に注意して下さい！
尚、ココを図示して説明して居るのは、
解説『画像メモリ概要』です！
因みにファイル「TypeArray.h」・「TypeArray.cpp」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－７）インライン関数
public: // inline 関数
inline int maxX(void){ return( h - 1 ); } // 最大Ｘ座標
inline int maxY(void){ return( v - 1 ); } // 最大Ｙ座標
inline int size(void){ return( h * v ); } // 画素数
inline int sizePix(void) // BYTE換算単位サイズ
{ //
if( w == 101 ){ // 単精度なら
return( 4 ); // ４を答えとする
}else if( w == 102 ){ // 倍精度なら
return( 8 ); // ８を答えとする
}else{ // 1/2/4BYTEなら
return( w ); // 左記で算出
} //
} //
inline int sizeMem(void){ // メモリサイズ
return( size() * sizePix() ); } // ＝画素数×単位サイズ
inline int sizeInc(void){ // BYTE換算増加幅
return( inc * sizePix() ); } // ＝増加幅×単位サイズ
inline void freeMem(void) // メモリ解放
{ //
if( adr != 0 ){ // メモリ取得済みなら
free( (void*)adr ); // メモリを解放し
adr = 0; // アドレスを初期化
} //
}
inline int check( int x, int y ){ // 検査：全般
if( adr <= 0 || x < 0 || x >= h // アドレスや
|| y < 0 || y >= v ){ // 座標が不正なら、
return( STI_FLG ); // 不正を返す
} //
return( END_STI ); // 正常終了
}
inline int checkXY( int x, int y ){ // 検査：座標
if( x < 0 || x >= h || y < 0 || y >= v ){ // 座標が不正
return( STI_FLG ); // なら、不正を返す
} //
return( END_STI ); // 正常終了
}
inline int getByte( int x, int y ){ // 画素取り出し
return( *( (BYTE*)adr + x + y * inc ) ); } // BYTE単位
inline int getShort( int x, int y ){ // 画素取り出し
return( *( (short*)adr + x + y * inc ) ); } // short単位
inline int getInt( int x, int y ){ // 画素取り出し
return( *( (int*)adr + x + y * inc ) ); } // int単位
inline double getFloat( int x, int y ){ // 画素取り出し
return( *( (float*)adr + x + y * inc ) ); } // 単精度単位
inline double getDouble( int x, int y ){ // 画素取り出し
return( *( (double*)adr + x + y * inc ) ); } // 倍精度単位
inline void putByte( int x, int y, int d ){ // 画素書き込み
*( (BYTE*)adr + x + y * inc ) = d; } // BYTE単位
inline void putShort( int x, int y, int d ){ // 画素書き込み
*( (short*)adr + x + y * inc ) = d; } // short単位
inline void putInt( int x, int y, int d ){ // 画素書き込み
*( (int*)adr + x + y * inc ) = d; } // int単位
inline void putFloat( int x, int y, double d ){ // 画素書き込み
*( (float*)adr + x + y * inc ) = (float)d; } // 単精度単位
inline void putDouble( int x, int y, double d ){ // 画素書き込み
*( (double*)adr + x + y * inc ) = d; } // 倍精度単位
inline BYTE* getPtrByte( int x, int y ){ // 画素アクセスポインタ取出
return( (BYTE*)adr + x + y * inc ); } // BYTE単位
inline short* getPtrShort( int x, int y ){ // 画素アクセスポインタ取出
return( (short*)adr + x + y * inc ); } // short単位
inline int* getPtrInt( int x, int y ){ // 画素アクセスポインタ取出
return( (int*)adr + x + y * inc ); } // int単位
inline float* getPtrFloat( int x, int y ){ // 画素アクセスポインタ取出
return( (float*)adr + x + y * inc ); } // 単精度単位
inline double* getPtrDouble( int x, int y ){ // 画素アクセスポインタ取出
return( (double*)adr + x + y * inc ); } // 倍精度単位
};勿論、高速化の為に「インライン関数」⇒
「使用した所に関数呼び出しで無く、展開して機械コードに
成る」にしたのですが？！
読んで頂ければ、判る様に関数呼び出し依りも機械コードに
展開した時にコード自体のサイズも小さく成る可能性が高い
物と「本当に小さな」物です！
因みにファイル「TypeArray.h」は、
解説『投げ銭方式ライブラリのダウンロード』で
ダウンロード出来ます★無料です！★
（２－７－１）関数「maxX(void)」
inline int maxX(void){ return( h - 1 ); } // 最大Ｘ座標（２－７－１－Ａ）関数名「maxX(void);」
「max」は、英単語「maximum」の略≪最大≫を意味する
英単語です！
「X」は、Ｘ座標を示します！
機能としては、画像のＸ座標最大値＝右端座標の値を算出で
す！
（２－７－１－Ｂ）関数「maxX(void);」【アルゴリズム】
「inline」は、勿論、インライン関数をしめします！
「{return(h-1);}」は、「{・・中身・・}」で中身が、
「return(h-1);」とリターン値が「h-1」と、
このクラス「TypeArray」のメンバー変数「h」水平幅から
「-1」した数を返します！
（２－７－２－Ａ）関数名「maxY(void);」
inline int maxY(void){ return( v - 1 ); } // 最大Ｙ座標「max」は、英単語「maximum」の略≪最大≫を意味する
英単語です！
「Y」は、Ｙ座標を示します！
機能としては、画像のＹ座標最大値＝下端座標の値を算出で
す！
（２－７－２－Ｂ）関数「minY(void);」【アルゴリズム】
inline int maxY(void){ return( v - 1 ); } // 最大Ｙ座標「inline」は、勿論、インライン関数をしめします！
「{return(v-1);}」は、「{・・中身・・}」で中身が、
「return(v-1);」とリターン値が「v-1」と、
このクラス「TypeArray」のメンバー変数「v」垂直幅から
「-1」した数を返します！
（２－７－３－Ａ）関数名「size(void);」
inline int size(void){ return( h * v ); } // 画素数「size」は、サイズを意味する英単語です！
ここでは、画像の画素のサイズを示します！
（２－７－３－Ｂ）関数「size(void);」【アルゴリズム】
inline int size(void){ return( h * v ); } // 画素数「inline」は、勿論、インライン関数をしめします！
「{return(h * v);}」は、「{・・中身・・}」で中身が、
「return(h * v);」とリターン値が「h * v」と、
このクラス「TypeArray」のメンバー変数「h」水平幅と
垂直幅を乗算した値を返します！
全体の画像全体の画素数に成ります！
（２－７－４－Ａ）関数名「sizePix(void);」
inline int sizePix(void) // BYTE換算単位サイズ
{ //
if( w == 101 ){ // 単精度なら
return( 4 ); // ４を答えとする
}else if( w == 102 ){ // 倍精度なら
return( 8 ); // ８を答えとする
}else{ // 1/2/4BYTEなら
return( w ); // 左記で算出
} //
} // 「size」は、サイズを意味する英単語です！
「Pix」は、ピクセルの略称です！
ここでは、画素自体のサイズ≪バイト数≫を示します！
（２－７－４－Ｂ）関数「sizePix(void);」【アルゴリズム】
{ //
if( w == 101 ){ // 単精度なら
return( 4 ); // ４を答えとする
}else if( w == 102 ){ // 倍精度なら
return( 8 ); // ８を答えとする
}else{ // 1/2/4BYTEなら
return( w ); // 左記で算出
} //
} //「inline」は、勿論、インライン関数をしめします！
「if(w==101){return(4);}」は、条件「w==101」で
単精度浮動小数点数値を示すので中身「return(4);」と４を
返します！
「}elseif(w==102){return(8);}」は、条件「w==102」で
倍精度浮動小数点数値を示すので中身「return(8);」と８を
返します！
「}else{return(w);}」は、それ以外の場合なので
中身「return(w);」とメンバー変数「w」の値を返します！
★注意★勿論、
メンバー関数「Malloc（）系・SetByte（）系」を使用して
メンバー変数「w」の値が正規に設定されている事が前提
条件です！
☆備考☆
メンバー変数もパブリック属性にして外からアクセス可能に
しているので変な事を読者様が行えば、正常に動作シナイ事
に成る場合が有る事は、十分に理解して頂いて居ると思い
ます！
（２－７－５－Ａ）関数名「sizeMem(void);」
inline int sizeMem(void){ // メモリサイズ
return( size() * sizePix() ); } // ＝画素数×単位サイズ
「size」は、サイズを意味する英単語です！
「Mem」は、メモリーの略称です！
ここでは、画像メモリのサイズ≪総バイト数≫を示します！
（２－７－５－Ｂ）関数「sizeMem(void);」【アルゴリズム】
inline int sizeMem(void){ // メモリサイズ
return( size() * sizePix() ); } // ＝画素数×単位サイズ「inline」は、勿論、インライン関数を示します！
「{return( size() * sizePix() }」は、
「{・・中身・・}」で中身が、
「return(size() * sizePix());」とリターン値が、
「size() * sizePix()」と、先ほど解説した関数「size()」
と関数「sizePix()」を乗算する事で総バイト数を算出し
値を返します！
（２－７－６－Ａ）関数名「sizeInc(void);」
inline int sizeInc(void){ // BYTE換算増加幅
return( inc * sizePix() ); } // ＝増加幅×単位サイズ
「size」は、サイズを意味する英単語です！
「Inc」は、増加幅を示します！
ここでは、画像メモリの縦方向に移動する場合の増加サイズ
≪バイト数≫を示します！
★注意★増加幅に関しては、解説『画像メモリ概要』を参考
にして下さい！
（２－７－６－Ｂ）関数「sizeInc(void);」【アルゴリズム】
inline int sizeInc(void){ // BYTE換算増加幅
return( inc * sizePix() ); } // ＝増加幅×単位サイズ「inline」は、勿論、インライン関数をしめします！
「{return(inc * sizePix()}」は、「{・・中身・・}」で
中身が、「return(inc * sizePix());」とリターン値が、
「inc * sizePix()」と、メンバー変数「inc」と先ほど
解説した関数「sizePix()」を乗算する事で増加するとき
に移動するバイト数を算出し値を返します！
（２－７－７－Ａ）関数名「freeMem(void);」
inline void freeMem(void) // メモリ解放
{ //
if( adr != 0 ){ // メモリ取得済みなら
free( (void*)adr ); // メモリを解放し
adr = 0; // アドレスを初期化
} //
}「free」は、解放を意味する英単語です！
「Mem」は、メモリーの略称です！
ここでは、画像メモリの解放≪システムから取得した動的
メモリ領域をシステムに返す≫を行います！
★注意★
勿論、画像メモリの取得関数としてメンバー関数
「Malloc（）系」で取得した画像メモリの明示的な解放
です！
★備考★
コンストラクタ「TypeArray()」では、「adr=0」と単に
初期化するだけです！メンバー関数「Malloc（）系」で
取得した画像メモリは明示的に解放する必要が有り、
デストラクタ「^TypeArray()」が、何もシナイ関数で有る
事は、御存知ですね！
詰り、明示的に解放しないとメモリはシステムに還りま
せんので下手なソースコードを動かすとメモリシステムが
破綻します
尚、クラス「CopyClear」以降のクラス「Support」を
継承している画像処理本体を記述しているクラスの中では
「Malloc（）系」で取得した画像メモリは、
この「freeMem(void);」で確実に解放して居ます！
（２－７－７－Ｂ）関数「freeMem(void);」【アルゴリズム】
inline void freeMem(void) // メモリ解放
{ //
if( adr != 0 ){ // メモリ取得済みなら
free( (void*)adr ); // メモリを解放し
adr = 0; // アドレスを初期化
} //
}「inline」は、勿論、インライン関数をしめします！
「if(adr!=0){free((void*)adr);adr=0;}」は、
条件「adr!=0」とメンバー変数「adr」が「０で無い、
詰り、空ポインタで無く有効な値」が入って居る場合
「{free((void*)adr);adr=0;}」とＣ言語標準のメモリ解放
関数「free(void*);」、でメンバー変数「adr」が示して
いる取得したメモリ「Ｃ言語標準malloc（）関数で取得」を
解放します！
★★注意★★
勿論、このインライン関数で一番重要な関数です！！
☆☆備考☆☆何故、コンストラクタ／デストラクタで
綺麗にメモリが解放しないかと言うと？！
勿論、物理的に特殊な「表示用」画像メモリや画像自体
をキャプチャーする為に必要な画像メモリーへ割り当てる
「SetByte()系」の関数を使う場合と、【部分画像】が
使用出来る様にした為です！
ここの所も理解して頂きたい！！
（２－７－８－Ａ）関数名「check( int x, int y );」
inline int check( int x, int y ){ // 検査：全般
if( adr <= 0 || x < 0 || x >= h // アドレスや
|| y < 0 || y >= v ){ // 座標が不正なら、
return( STI_FLG ); // 不正を返す
} //
return( END_STI ); // 正常終了
}「check」は、検査チェックを意味する英単語です！
ここでは、画像メモリが使用可能かチェックし、
指定ＸＹ座標が画像の範囲内に収まるか否かのチェックです！
（２－７－８－Ｂ）関数「check();」【仮引数】
inline int check( int x, int y ){「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
（２－７－８－Ｃ）関数「check();」【アルゴリズム】
inline int check( int x, int y ){ // 検査：全般
if( adr <= 0 || x < 0 || x >= h // アドレスや
|| y < 0 || y >= v ){ // 座標が不正なら、
return( STI_FLG ); // 不正を返す
} //
return( END_STI ); // 正常終了
}「if(adr<=0||x<0||x>=h||y<0||y>=v){return(STI_FLG);}」
は、条件「adr<=0||x<0||x>=h||y<0||y>=v」で先ず、
「adr<=0」で画像メモリが正常か否か、
「x<0||x>=h||y<0||y>=v」でＸＹ座標が画像の範囲内に
入って居るか範囲外かを判断し、適合シナイ場合、
リターン値「STI_FLG」とエラーを返し、正常なら、
リターン値「END_STI」と正常終了！
（２－７－９－Ａ）関数名「checkXY( int x, int y );」
inline int checkXY( int x, int y ){ // 検査：座標
if( x < 0 || x >= h || y < 0 || y >= v ){ // 座標が不正
return( STI_FLG ); // なら、不正を返す
} //
return( END_STI ); // 正常終了
}「check」は、検査チェックを意味する英単語です！
ここでは、指定ＸＹ座標が画像の範囲内に収まるか否かの
チェックです！
（２－７－９－Ｂ）関数「checkXY();」【仮引数】
inline int checkXY( int x, int y ){「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
（２－７－９－Ｃ）関数「check();」【アルゴリズム】
inline int checkXY( int x, int y ){ // 検査：座標
if( x < 0 || x >= h || y < 0 || y >= v ){ // 座標が不正
return( STI_FLG ); // なら、不正を返す
} //
return( END_STI ); // 正常終了
}「if(x<0||x>=h||y<0||y>=v){return(STI_FLG);}」は、
条件「x<0||x>=h||y<0||y>=v」で「x<0||x>=h||y<0||y>=v」
でＸＹ座標が画像の範囲内に入って居るか範囲外かを
判断し、適合シナイ場合、リターン値「STI_FLG」と
エラーを返し、正常なら、リターン値「END_STI」と
正常終了！
（２－７－９－Ａ）関数名「getByte( int x, int y );」
inline int getByte( int x, int y ){ // 画素取り出し
return( *( (BYTE*)adr + x + y * inc ) ); } // BYTE単位「get」は、ゲット、日本語でも取得するを意味する用語と
して今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素を取り出す事を意味
します！
「Byte」は、「BYTE型」＝「unsigned char」と１バイト
符号無し整数型を示します！何故、「Byte」と記載したか
は、「英大文字」を区切りとして使用し後を小文字にして
区切った表記上の手法です！
（２－７－９－Ｂ）関数「getByte();」【仮引数】
inline int getByte( int x, int y ){ 「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
（２－７－９－Ｃ）関数「getByte();」【アルゴリズム】
inline int getByte( int x, int y ){ // 画素取り出し
return( *( (BYTE*)adr + x + y * inc ) ); } // BYTE単位「return(* ( (BYTE*)adr + x + y * inc ) );」と
ＸＹ座標のチェック無しで単に
「(BYTE*)adr + x + y * inc」と「adr」と画像メモリ
原点に「x + y * inc」ＸＹ座標の増分を算出し画素の
データを取り出します！
★注意★チェック無しで正しい画像＆座標値が前提です！
（２－７－１０－Ａ）関数名「getShort( int x, int y );」
inline int getShort( int x, int y ){ // 画素取り出し
return( *( (short*)adr + x + y * inc ) ); } // short単位「get」は、ゲット、日本語でも取得するを意味する用語
として今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素を取り出す事を意味
します！
「Short」は、「short型」と２バイト符号有り整数型を
示します！何故、「Short」と記載したかは、「英大文字」
を区切りとして使用し後を小文字にして区切った表記上の
手法です！
（２－７－１０－Ｂ）関数「getShort();」【仮引数】
inline int getShort( int x, int y ){ 「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
（２－７－１０－Ｃ）関数「getShort();」【アルゴリズム】
inline int getShort( int x, int y ){ // 画素取り出し
return( *( (short*)adr + x + y * inc ) ); } // short単位「return( *( (short*)adr + x + y * inc ) );」とＸＹ
座標のチェック無しで単に「(short*)adr + x + y * inc」
と「adr」と画像メモリ原点に「x + y * inc」ＸＹ座標の
増分を算出し画素のデータを取り出します！
★注意★チェック無しで正しい画像＆座標値が前提です！
（２－７－１１－Ａ）関数名「getInt( int x, int y );」
inline int getInt( int x, int y ){ // 画素取り出し
return( *( (int*)adr + x + y * inc ) ); } // int単位「get」は、ゲット、日本語でも取得するを意味する用語
として今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素を取り出す事を意味
します！
「Int」は、「int型」と４バイト符号有り整数型を
示します！何故、「Int」と記載したかは、「英大文字」を
区切りとして使用し後を小文字にして区切った表記上の
手法です！
（２－７－１１－Ｂ）関数「getInt();」【仮引数】
inline int getInt( int x, int y ){ 「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
（２－７－１１－Ｃ）関数「getInt();」【アルゴリズム】
inline int getInt( int x, int y ){ // 画素取り出し
return( *( (int*)adr + x + y * inc ) ); } // int単位「return( *( (int*)adr + x + y * inc ) );」とＸＹ座標
のチェック無しで単に「(int*)adr + x + y * inc」と
「adr」と画像メモリ原点に「x + y * inc」ＸＹ座標の
増分を算出し画素のデータを取り出します！
★注意★チェック無しで正しい画像＆座標値が前提です！
（２－７－１２－Ａ）関数名「getFloat( int x, int y );」
inline double getFloat( int x, int y ){ // 画素取り出し
return( *( (float*)adr + x + y * inc ) ); } // 単精度単位「get」は、ゲット、日本語でも取得するを意味する用語
として今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素を取り出す事を意味し
ます！
「Float」は、「float型」と４バイト単精度浮動小数点数
値型を示します！何故、「Float」と記載したかは、
「英大文字」を区切りとして使用し後を小文字にして
区切った表記上の手法です！
（２－７－１２－Ｂ）関数「getFloat();」【仮引数】
inline double getFloat( int x, int y ){「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
（２－７－１２－Ｃ）関数「getFloat();」【アルゴリズム】
inline double getFloat( int x, int y ){ // 画素取り出し
return( *( (float*)adr + x + y * inc ) ); } // 単精度単位「return( *( (float*)adr + x + y * inc ) );」と
ＸＹ座標のチェック無しで単に
「(float*)adr + x + y * inc」と「adr」と画像メモリ
原点に「x + y * inc」ＸＹ座標の増分を算出し画素の
データを取り出します！
★注意★チェック無しで正しい画像＆座標値が前提です！
（２－７－１３－Ａ）関数名「getDouble( int x, int y );」
inline double getDouble( int x, int y ){ // 画素取り出し
return( *( (double*)adr + x + y * inc ) ); } // 倍精度単位
「get」は、ゲット、日本語でも取得するを意味する用語と
して今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素を取り出す事を意味
します！
「Double」は、「double型」と８バイト倍精度浮動小数点
数値型を示します！
何故、「Double」と記載したかは、「英大文字」を区切り
として使用し後を小文字にして区切った表記上の手法です！
（２－７－１３－Ｂ）関数「getDouble();」【仮引数】
inline double getDouble( int x, int y ){「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
（２－７－１３－Ｃ）関数「getDouble();」【アルゴリズム】
inline double getDouble( int x, int y ){ // 画素取り出し
return( *( (double*)adr + x + y * inc ) ); } // 倍精度単位「return( *( (double*)adr + x + y * inc ) );」と
ＸＹ座標のチェック無しで単に
「(double*)adr + x + y * inc」と「adr」と画像メモリ
原点に「x + y * inc」ＸＹ座標の増分を算出し画素の
データを取り出します！
★注意★チェック無しで正しい画像＆座標値が前提です！
（２－７－１４－Ａ）関数名「putByte( int x, int y );」
inline void putByte( int x, int y, int d ){ // 画素書き込み
*( (BYTE*)adr + x + y * inc ) = d; } // BYTE単位「put」は、プット、日本語でも「物などを場所に置く」を意味する用語として今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素へ書き込む事を意味し
ます！
「Byte」は、「BYTE型」＝「unsigned char」と１バイト
符号無し整数型を示します！何故、「Byte」と記載したか
は、「英大文字」を区切りとして使用し後を小文字にして
区切った表記上の手法です！
（２－７－１４－Ｂ）関数「putByte();」【仮引数】
inline void putByte( int x, int y, int d ){「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
「int d」は、画素に書き込むデータです！
（２－７－１４－Ｃ）関数「putByte();」【アルゴリズム】
inline void putByte( int x, int y, int d ){ // 画素書き込み
*( (BYTE*)adr + x + y * inc ) = d; } // BYTE単位「*( (BYTE*)adr + x + y * inc ) = d;」とＸＹ座標の
チェック無しで単に
「(BYTE*)adr + x + y * inc」と「adr」と画像メモリ原点
に「x + y * inc」ＸＹ座標の増分を算出し画素の
ポインタを算出し、それにデータを書き込みます！
★注意★チェック無しで正しい画像＆座標値が前提です！
（２－７－１５－Ａ）関数名「putShort( int x, int y );」
inline void putShort( int x, int y, int d ){ // 画素書き込み
*( (short*)adr + x + y * inc ) = d; } // short単位「put」は、プット、日本語でも「物などを場所に置く」を
意味する用語として今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素へ書き込む事を意味
します！
「Short」は、「short型」と２バイト符号有り整数型を
示します！
何故、「Short」と記載したかは、「英大文字」を区切り
として使用し後を小文字にして区切った表記上の手法で
す！
（２－７－１５－Ｂ）関数「putShort();」【仮引数】
inline void putShort( int x, int y, int d ){「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
「int d」は、画素に書き込むデータです！
（２－７－１５－Ｃ）関数「putShort();」【アルゴリズム】
inline void putShort( int x, int y, int d ){ // 画素書き込み
*( (short*)adr + x + y * inc ) = d; } // short単位「*( (short*)adr + x + y * inc ) = d;」とＸＹ座標の
チェック無しで単に「(short*)adr + x + y * inc」と
「adr」と画像メモリ原点に「x + y * inc」ＸＹ座標の
増分を算出し画素のポインタを算出し、それにデータを
書き込みます！
★注意★チェック無しで正しい画像＆座標値が前提です！
（２－７－１６－Ａ）関数名「putInt( );」
inline void putInt( int x, int y, int d ){ // 画素書き込み
*( (int*)adr + x + y * inc ) = d; } // int単位「put」は、プット、日本語でも「物などを場所に置く」を
意味する用語として今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素へ書き込む事を意味
します！
「Int」は、「int型」と４バイト符号有り整数型を
示します！何故、「Int」と記載したかは、「英大文字」を
区切りとして使用し後を小文字にして区切った表記上の
手法です！
（２－７－１６－Ｂ）関数「putInt();」【仮引数】
inline void putInt( int x, int y, int d ){ 「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
「int d」は、画素に書き込むデータです！
（２－７－１６－Ｃ）関数「putInt();」【アルゴリズム】
inline void putInt( int x, int y, int d ){ // 画素書き込み
*( (int*)adr + x + y * inc ) = d; } // int単位「*( (int*)adr + x + y * inc ) = d;」とＸＹ座標の
チェック無しで単に「(int*)adr + x + y * inc」と
「adr」と画像メモリ原点に「x + y * inc」ＸＹ座標の
増分を算出し画素のポインタを算出し、それにデータを
書き込みます！
★注意★チェック無しで正しい画像＆座標値が前提です！
（２－７－１７－Ａ）関数名「putFloat( );」
inline void putFloat( int x, int y, double d ){ // 画素書き込み
*( (float*)adr + x + y * inc ) = (float)d; } // 単精度単位「put」は、プット、日本語でも「物などを場所に置く」を
意味する用語として今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素へ書き込む事を意味
します！
「Float」は、「float型」と４バイト単精度浮動小数点数値
型を示します！何故、「Float」と記載したかは、
「英大文字」を区切りとして使用し後を小文字にして
区切った表記上の手法です！
（２－７－１７－Ｂ）関数「putFloat();」【仮引数】
inline void putFloat( int x, int y, double d ){「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
「double d」は、画素に書き込むデータです！
（２－７－１７－Ｃ）関数「putFloat();」【アルゴリズム】
inline void putFloat( int x, int y, double d ){ // 画素書き込み
*( (float*)adr + x + y * inc ) = (float)d; } // 単精度単位「*( (float*)adr + x + y * inc ) = d;」とＸＹ座標の
チェック無しで単に「(float*)adr + x + y * inc」と
「adr」と画像メモリ原点に「x + y * inc」ＸＹ座標の
増分を算出し画素のポインタを算出し、それにデータを
書き込みます！
★注意★チェック無しで正しい画像＆座標値が前提です！
（２－７－１８－Ａ）関数名「putDouble( int x, int y );」
inline void putDouble( int x, int y, double d ){ // 画素書き込み
*( (double*)adr + x + y * inc ) = d; } // 倍精度単位「put」は、プット、日本語でも「物などを場所に置く」を
意味する用語として今は、認知されている筈ですね！
ここでは、元の画像の任意の１画素へ書き込む事を意味
します！
「Double」は、「double型」と８バイト倍精度浮動小数点数
値型を示します！
何故、「Double」と記載したかは、「英大文字」を区切り
として使用し後を小文字にして区切った表記上の手法です！
（２－７－１８－Ｂ）関数「putDouble();」【仮引数】
inline void putDouble( int x, int y, double d ){ 「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
「double d」は、画素に書き込むデータです！
（２－７－１８－Ｃ）関数「putDouble();」【アルゴリズム】
inline void putDouble( int x, int y, double d ){ // 画素書き込み
*( (double*)adr + x + y * inc ) = d; } // 倍精度単位「*( (double*)adr + x + y * inc ) = d;」とＸＹ座標の
チェック無しで単に「(double*)adr + x + y * inc」と
「adr」と画像メモリ原点に「x + y * inc」ＸＹ座標の
増分を算出し画素のポインタを算出し、それにデータを
書き込みます！
★注意★チェック無しで正しい画像＆座標値が前提です！
（２－７－１９－Ａ）関数名「getPtrByte( int x, int y );」
inline BYTE* getPtrByte( int x, int y ){ // 画素アクセスポインタ取出
return( (BYTE*)adr + x + y * inc ); } // BYTE単位「get」は、ゲット、日本語でも取得するを意味する用語
として今は、認知されている筈ですね！
「Ptr」は、ポインタの略です！
ここでは、元の画像の任意の１画素へのポインタを算出
する事を意味します！
「Byte」は、「BYTE型」＝「unsigned char」と１バイト
符号無し整数型を示します！何故、「Byte」と記載した
かは、「英大文字」を区切りとして使用し後を小文字に
して区切った表記上の手法です！
（２－７－１９－Ｂ）関数「getPtrByte();」【仮引数】
inline BYTE* getPtrByte( int x, int y ){「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
（２－７－１９－Ｃ）関数「getPtrByte();」【アルゴリズム】
inline BYTE* getPtrByte( int x, int y ){ // 画素アクセスポインタ取出
return( (BYTE*)adr + x + y * inc ); } // BYTE単位「return( ( (BYTE*)adr + x + y * inc ) );」と
ＸＹ座標のチェック無しで単に
「(BYTE*)adr + x + y * inc」と「adr」と画像メモリ
原点に「x + y * inc」ＸＹ座標の増分を算出し画素の
データを取り出します！
★注意★チェック無しで正しい画像＆座標値が前提です！
（２－７－２０－Ａ）関数名「getPtrShort( );」
inline short* getPtrShort( int x, int y ){ // 画素アクセスポインタ取出
return( (short*)adr + x + y * inc ); } // short単位「get」は、ゲット、日本語でも取得するを意味する用語と
して今は、認知されている筈ですね！
「Ptr」は、ポインタの略です！
ここでは、元の画像の任意の１画素へのポインタを算出する
事を意味します！
「Short」は、「short型」と２バイト符号有り整数型を
示します！何故、「Short」と記載したかは、「英大文字」
を区切りとして使用し後を小文字にして区切った表記上の
手法です！
（２－７－２０－Ｂ）関数「getPtrShort();」【仮引数】
inline short* getPtrShort( int x, int y ){ 「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
（２－７－２０－Ｃ）関数「getPtrShort();」【アルゴリズム】
inline short* getPtrShort( int x, int y ){ // 画素アクセスポインタ取出
return( (short*)adr + x + y * inc ); } // short単位「return( ( (short*)adr + x + y * inc ) );」と
ＸＹ座標のチェック無しで単に
「(short*)adr + x + y * inc」と「adr」と画像メモリ
原点に「x + y * inc」ＸＹ座標の増分を算出し画素の
データを取り出します！
★注意★チェック無しで正しい画像＆座標値が前提です！
（２－７－２１－Ａ）関数名「getPtrInt( );」
inline int* getPtrInt( int x, int y ){ // 画素アクセスポインタ取出
return( (int*)adr + x + y * inc ); } // int単位「get」は、ゲット、日本語でも取得するを意味する用語と
して今は、認知されている筈ですね！
「Ptr」は、ポインタの略です！
ここでは、元の画像の任意の１画素へのポインタを算出する
事を意味します！
「Int」は、「int型」と４バイト符号有り整数型を
示します！何故、「Int」と記載したかは、「英大文字」を
区切りとして使用し後を小文字にして区切った表記上の手法
です！
（２－７－２１－Ｂ）関数「getPtrInt();」【仮引数】
inline int* getPtrInt( int x, int y ){「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
（２－７－２１－Ｃ）関数「getPtrInt();」【アルゴリズム】
inline int* getPtrInt( int x, int y ){ // 画素アクセスポインタ取出
return( (int*)adr + x + y * inc ); } // int単位「return( ( (int*)adr + x + y * inc ) );」と
ＸＹ座標のチェック無しで単に
「(int*)adr + x + y * inc」と「adr」と画像メモリ原点に
「x + y * inc」ＸＹ座標の増分を算出し画素のデータを
取り出します！
★注意★チェック無しで正しい画像＆座標値が前提です！
（２－７－２２－Ａ）関数名「getPtrFloat( );」
inline float* getPtrFloat( int x, int y ){ // 画素アクセスポインタ取出
return( (float*)adr + x + y * inc ); } // 単精度単位
「get」は、ゲット、日本語でも取得するを意味する用語と
して今は、認知されている筈ですね！
「Ptr」は、ポインタの略です！
ここでは、元の画像の任意の１画素へのポインタを算出する
事を意味します！
「Float」は、「float型」と４バイト単精度浮動小数点数値
型を示します！
何故、「Float」と記載したかは、「英大文字」を区切り
として使用し後を小文字にして区切った表記上の手法です！
（２－７－２２－Ｂ）関数「getPtrFloat();」【仮引数】
inline float* getPtrFloat( int x, int y ){ 「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
（２－７－２２－Ｃ）関数「getPtrFloat();」【アルゴリズム】
inline float* getPtrFloat( int x, int y ){ // 画素アクセスポインタ取出
return( (float*)adr + x + y * inc ); } // 単精度単位「return( ( (float*)adr + x + y * inc ) );」と
ＸＹ座標のチェック無しで単に
「(float*)adr + x + y * inc」と「adr」と画像メモリ
原点に「x + y * inc」ＸＹ座標の増分を算出し画素の
データを取り出します！
★注意★チェック無しで正しい画像＆座標値が前提です！
（２－７－２３－Ａ）関数名「getPtrDouble(
int x, int y );」
inline double* getPtrDouble( int x, int y ){ // 画素アクセスポインタ取出
return( (double*)adr + x + y * inc ); } // 倍精度単位「get」は、ゲット、日本語でも取得するを意味する用語
として今は、認知されている筈ですね！
「Ptr」は、ポインタの略です！
ここでは、元の画像の任意の１画素へのポインタを算出
する事を意味します！
「Double」は、「double型」と８バイト倍精度浮動小数点
数値型を示します！
何故、「Double」と記載したかは、「英大文字」を区切り
として使用し後を小文字にして区切った表記上の手法です！
（２－７－２３－Ｂ）関数「getPtrDouble();」【仮引数】
inline double* getPtrDouble( int x, int y ){「int x,」は、Ｘ座標です！
「int y」は、Ｙ座標です！
（２－７－２３－Ｃ）関数「getPtrDouble();」【アルゴリズム】
inline double* getPtrDouble( int x, int y ){ // 画素アクセスポインタ取出
return( (double*)adr + x + y * inc ); } // 倍精度単位「return( ( (double*)adr + x + y * inc ) );」と
ＸＹ座標のチェック無しで単に
「(double*)adr + x + y * inc」と「adr」と画像メモリ
原点に「x + y * inc」ＸＹ座標の増分を算出し画素の
データを取り出します！
★注意★チェック無しで正しい画像＆座標値が前提です！
ココまででクラス「TypeArray」の解説が完了します！
お付き合い！ありがとうございました！
尚、Ｎｏｔｅエディタの特性で半角「*」が
コピペ時に消えるとかの不具合を修正する為に補修が
入る事が有る事は理解して下さい！
解説文末
この記事が気に入ったらサポートをしてみませんか？