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