見出し画像

解説クラス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エディタの特性で半角「*」が
コピペ時に消えるとかの不具合を修正する為に補修が
入る事が有る事は理解して下さい!

解説文末

いいなと思ったら応援しよう!