見出し画像

解説クラスCopyClear(7)

解説クラスCopyClear(7)


2024年3月3初講(初稿)

この講義は解説『解説クラスCopyClear(6)』
続きです!

(4-11)元private属性としたサブルーチン的な関数群

public:                                         // TypeArrayと実配列とのデータ交換

    BYTE*   MoveArrayByte(                          // 配列→バッファー:BYTE
                TypeArray   *p,                     // 配列
                BYTE        buf[],                  // バッファー
                int         size                    // サイズ
            );
    short*  MoveArrayShort(                         // 配列→バッファー:short
                TypeArray   *p,                     // 配列
                short       buf[],                  // バッファー
                int         size                    // サイズ
            );
    long*   MoveArrayLong(                          // 配列→バッファー:long
                TypeArray   *p,                     // 配列
                long        buf[],                  // バッファー
                int         size                    // サイズ
            );
    int*    MoveArrayInt(                           // 配列→バッファー:int
                TypeArray   *p,                     // 配列
                int         buf[],                  // バッファー
                int         size                    // サイズ
            );
    float*  MoveArrayFloat(                         // 配列→バッファー:float
                TypeArray   *p,                     // 配列
                float       buf[],                  // バッファー
                int         size                    // サイズ
            );
    double* MoveArrayDouble(                        // 配列→バッファー:double
                TypeArray   *p,                     // 配列
                double      buf[],                  // バッファー
                int         size                    // サイズ
            );
    int     MoveCopyArrayByte(                      // 配列→buf:BYTE:完全
                TypeArray   *p,                     // 配列
                BYTE        buf[],                  // バッファー
                int         size                    // サイズ
            );
    int     MoveCopyArrayShort(                     // 配列→buf:short:完全
                TypeArray   *p,                     // 配列
                short       buf[],                  // バッファー
                int         size                    // サイズ
            );
    int     MoveCopyArrayLong(                      // 配列→buf:long:完全
                TypeArray   *p,                     // 配列
                long        buf[],                  // バッファー
                int         size                    // サイズ
            );
    int     MoveCopyArrayInt(                       // 配列→buf:int:完全
                TypeArray   *p,                     // 配列
                int         buf[],                  // バッファー
                int         size                    // サイズ
            );
    int     MoveCopyArrayFloat(                     // 配列→buf:float:完全
                TypeArray   *p,                     // 配列
                float       buf[],                  // バッファー
                int         size                    // サイズ
            );
    int     MoveCopyArrayDouble(                    // 配列→buf:double:完全
                TypeArray   *p,                     // 配列
                double      buf[],                  // バッファー
                int         size                    // サイズ
            );
    int     MoveByteArray(                          // Buf→配列:BYTE
                BYTE        buf[],                  // バッファー
                TypeArray   *p,                     // 配列
                int         size                    // サイズ
            );
    int     MoveShortArray(                         // Buf→配列:short
                short       buf[],                  // バッファー
                TypeArray   *p,                     // 配列
                int         size                    // サイズ
            );
    int     MoveLongArray(                          // Buf→配列:long
                long        buf[],                  // バッファー
                TypeArray   *p,                     // 配列
                int         size                    // サイズ
            );
    int     MoveIntArray(                           // Buf→配列:int
                int         buf[],                  // バッファー
                TypeArray   *p,                     // 配列
                int         size                    // サイズ
            );
    int     MoveFloatArray(                         // Buf→配列:float
                float       buf[],                  // バッファー
                TypeArray   *p,                     // 配列
                int         size                    // サイズ
            );
    int     MoveDoubleArray(                        // Buf→配列:double
                double      buf[],                  // バッファー
                TypeArray   *p,                     // 配列
                int         size                    // サイズ
            );


public:                                             // 各種内部処理
    int     ClearRoundImageBase(                    // 周囲クリア:基本
                TypeArray   *pa,                    // 配列
                int         data,                   // データ:整数
                int         n1,                     // 水平線クリア回数
                int         n2                      // 垂直線クリア回数
            );
    int     ClearRoundImageBase(                    // 周囲クリア:基本
                TypeArray   *pa,                    // 配列
                double      data,                   // データ:実数
                int         n1,                     // 水平線クリア回数
                int         n2                      // 垂直線クリア回数
            );
    int     ClearRoundImage(                        // 周囲クリア
                TypeArray   *pa,                    // 配列
                int         data,                   // データ:整数
                int         n                       // クリア周回回数
            );
    int     ClearRoundImage(                        // 周囲クリア
                TypeArray   *pa,                    // 配列
                double      data,                   // データ:実数
                int         n                       // クリア周回回数
            );
    int     CopyRoundImage(                         // 周囲転送
                TypeArray   *ps,                    // S配列
                TypeArray   *pd,                    // D配列
                int         n                       // コピー周回回数
            );
    int     CopyRoundImageBase(                     // 周囲転送:基本
                TypeArray   *ps,                    // S配列
                TypeArray   *pd,                    // D配列
                int         n1,                     // 水平線コピー回数
                int         n2                      // 垂直線コピー回数
            );
public:             // 拡大・縮小
    int             MagnifyZoom(                    // 拡大・縮小
        TypeArray   *ps,                            // S配列
        TypeArray   *pd,                            // D配列
        double      zh,                             // 水平拡大率
        double      zv,                             // 垂直拡大率
        int         dataSize=1 );                   // 画素サイズ(省略時=1)
    int             MagnifyZoomInt(                 // 整数倍拡大
        TypeArray   *ps,                            // S配列
        TypeArray   *pd,                            // D配列
        int         zh,                             // 水平拡大率
        int         zv,                             // 垂直拡大率
        int         dataSize=1 );                   // 画素サイズ(省略時=1)
    int             MagnifyZoomInterpolate(         // 拡大・縮小:補間
        TypeArray   *ps,                            // S配列
        TypeArray   *pd,                            // D配列
        double      zh,                             // 水平拡大率
        double      zv,                             // 垂直拡大率
        double      offsetX=0.0,                    // 微少X座標オフセット
        double      offsetY=0.0,                    // 微少Y座標オフセット
        int         dataSize=1 );                   // 画素サイズ(省略時=1)
    int             MagnifyZoomInterpolateByte(     // 拡大・縮小:補間:BYTE専用
        TypeArray   *ps,                            // S配列
        TypeArray   *pd,                            // D配列
        double      zh,                             // 水平拡大率
        double      zv,                             // 垂直拡大率
        double      offsetX=0.0,                    // 微少X座標オフセット
        double      offsetY=0.0,                    // 微少Y座標オフセット
        int         dataSize=1 );                   // 画素サイズ(省略時=1)
    int             MagnifyAverage(                 // 縮小:平均化
        TypeArray   *ps,                            // S配列
        TypeArray   *pd,                            // D配列
        int         zh,                             // 水平縮小率 1,2,3,4...16
        int         zv,                             // 垂直縮小率 1,2,3,4...16
        int         sw=FALSE );                     // sw=偽(省略時:平均)、真→合計
public:             // 平行移動
    int             MoveImageByte(                  // 平行移動:補間:BYTE
        TypeArray*  ps,                             // S配列
        TypeArray*  pd,                             // D配列
        double      offsetX,                        // X座標(0.0~1.0)
        double      offsetY,                        // Y座標(0.0~1.0)
        int         dataSize=1 );                   // 画素サイズ
    int             MoveImageShort(                 // 平行移動:補間:short
        TypeArray*  ps,                             // S配列
        TypeArray*  pd,                             // D配列
        double      offsetX,                        // X座標(0.0~1.0)
        double      offsetY,                        // Y座標(0.0~1.0)
        int         dataSize=1 );                   // 画素サイズ
    int             MoveImageLong(                  // 平行移動:補間:long
        TypeArray*  ps,                             // S配列
        TypeArray*  pd,                             // D配列
        double      offsetX,                        // X座標(0.0~1.0)
        double      offsetY,                        // Y座標(0.0~1.0)
        int         dataSize=1 );                   // 画素サイズ
    int             MoveImageFloat(                 // 平行移動:補間:単精度
        TypeArray*  ps,                             // S配列
        TypeArray*  pd,                             // D配列
        double      offsetX,                        // X座標(0.0~1.0)
        double      offsetY,                        // Y座標(0.0~1.0)
        int         dataSize=1 );                   // 画素サイズ
public:
    int     SetMathematics(                         // 数学的設定
                int     sw                          // 0:degree/1:radian
            );

今回、紹介する関数です!

(4-11-1)関数「BYTE* MoveArrayBYTE (
TypeArray *p,BYTE buf[],int size);」

    BYTE*   MoveArrayByte(                          // 配列→バッファー:BYTE
                TypeArray   *p,                     // 配列
                BYTE        buf[],                  // バッファー
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Array」は、「TypeArray型」を意味し!
「BYTE 」は、「BYTE型」のデータ配列を意味します!
仮引数「TypeArray* p,」の形で格納されたデータを
仮引数「BYTE buf[],int size」の「BYTE型」のデータ配列
とサイズを示したC言語で扱い易い形に移動する為の関数で
す!
関数の返値は、「BYTE 」型で仮引数「TypeArray *p,」で
示すデータ配列が1バイト単位ならば、コピーする時間を
節約する為、仮引数「TypeArray* p,」のデータ配列を示す
ポインタの値を返しますが、「TypeArray* p,」が2バイト
以上のサイズならば、仮引数「BYTE buf[]」に型変換して
コピーし、仮引数「BYTE buf[]」のアドレスをポインタと
して返します!
★詳細★は、後で説明:【ファイル「CopyClear000.cpp」が
対象】します!

(4-11-2)関数「short* MoveArrayshort (
TypeArray *p,short buf[],int size);」

    short*  MoveArrayShort(                         // 配列→バッファー:short
                TypeArray   *p,                     // 配列
                short       buf[],                  // バッファー
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Array」は、「TypeArray型」を意味し!
「short 」は、「short型」のデータ配列を意味します!
仮引数「TypeArray* p,」の形で格納されたデータを
仮引数「short buf[],int size」の「short型」の
データ配列とサイズを示したC言語で扱い易い形に移動する
為の関数です!
関数の返値は、「short 」型で仮引数「TypeArray *p,」で
示すデータ配列が2バイト単位ならば、コピーする時間を
節約する為、仮引数「TypeArray* p,」のデータ配列を
示すポインタの値を返しますが、「TypeArray* p,」が
2バイト以外のサイズならば、仮引数「short buf[]」に
型変換してコピーし、仮引数「short buf[]」のアドレスを
ポインタとして返します!
★詳細★は、後で説明:【ファイル「CopyClear000.cpp」が
対象】します!

(4-11-3)関数「long* MoveArrayLong (
TypeArray *p,long buf[],int size);」

    long*   MoveArrayLong(                          // 配列→バッファー:long
                TypeArray   *p,                     // 配列
                long        buf[],                  // バッファー
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Array」は、「TypeArray型」を意味し!
「long 」は、「long型」のデータ配列を意味します!
仮引数「TypeArray* p,」の形で格納されたデータを
仮引数「long buf[],int size」の「long型」の
データ配列とサイズを示したC言語で扱い易い形に移動する
為の関数です!
関数の返値は、「long 」型で仮引数「TypeArray *p,」で
示すデータ配列が4バイト単位ならば、コピーする時間を
節約する為、仮引数「TypeArray* p,」のデータ配列を示す
ポインタの値を返しますが、「TypeArray* p,」が4バイト
以外のサイズならば、仮引数「long buf[]」に型変換して
コピーし、仮引数「long buf[]」のアドレスをポインタと
して返します!
★詳細★は、後で説明:【ファイル「CopyClear000.cpp」が
対象】します!

(4-11-4)関数「int MoveArrayInt((
TypeArray *p,int buf[],int size);」

    int*    MoveArrayInt(                           // 配列→バッファー:int
                TypeArray   *p,                     // 配列
                int         buf[],                  // バッファー
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Array」は、「TypeArray型」を意味し!
「int 」は、「int型」のデータ配列を意味します!
仮引数「TypeArray* p,」の形で格納されたデータを
仮引数「int buf[],int size」の「int型」の
データ配列とサイズを示したC言語で扱い易い形に移動する
為の関数です!
関数の返値は、「int 」型で仮引数「TypeArray *p,」で
示すデータ配列が4バイト単位ならば、コピーする時間を
節約する為、仮引数「TypeArray* p,」のデータ配列を示す
ポインタの値を返しますが、「TypeArray* p,」が2バイト
以外のサイズならば、仮引数「int buf[]」に型変換して
コピーし、仮引数「int buf[]」のアドレスをポインタと
して返します!
★詳細★は、後で説明:【ファイル「CopyClear000.cpp」が
対象】します!

(4-11-5)関数「float* MoveArrayFloat(
TypeArray *p,float buf[],int size);」

    float*  MoveArrayFloat(                         // 配列→バッファー:float
                TypeArray   *p,                     // 配列
                float       buf[],                  // バッファー
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Array」は、「TypeArray型」を意味し!
「Float」は、「float型」のデータ配列を意味します!
仮引数「TypeArray* p,」の形で格納されたデータを
仮引数「float buf[],int size」の「float型」の
データ配列とサイズを示したC言語で扱い易い形に移動する
為の関数です!
関数の返値は、「float*」型で仮引数「TypeArray* p,」で
示すデータ配列が単精度実数型を示す型ならば、コピーする
時間を節約する為、仮引数「TypeArray* p,」の
データ配列を示すポインタの値を返しますが、
「TypeArray* p,」が単精度実数型を示す型以外のサイズ
ならば、仮引数「float buf[]」に型変換してコピーし、
仮引数「float buf[]」のアドレスをポインタと
して返します!
★詳細★は、後で説明:【ファイル「CopyClear000.cpp」が
対象】します!

(4-11-6)関数「double MoveArraydouble (TypeArray p,double buf[],int size);」

    double* MoveArrayDouble(                        // 配列→バッファー:double
                TypeArray   *p,                     // 配列
                double      buf[],                  // バッファー
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Array」は、「TypeArray型」を意味し!
「double 」は、「double 型」のデータ配列を意味します!
仮引数「TypeArray* p,」の形で格納されたデータを
仮引数「double buf[],int size」の「double 型」の
データ配列とサイズを示したC言語で扱い易い形に移動する
為の関数です!
関数の返値は、「double 」型で仮引数「TypeArray *p,」で
示すデータ配列が倍精度実数型を示す型ならば、コピーする
時間を節約する為、仮引数「TypeArray* p,」の
データ配列を示すポインタの値を返しますが、
「TypeArray* p,」が倍精度実数型を示す型以外のサイズ
ならば、仮引数「double buf[]」に型変換してコピーし、
仮引数「double buf[]」のアドレスをポインタと
して返します!
★詳細★は、後で説明:【ファイル「CopyClear000.cpp」が
対象】します!

(4-11-7)関数「int MoveCopyArrayByte (
TypeArray* p,BYTE buf[],int size);」

    int     MoveCopyArrayByte(                      // 配列→buf:BYTE:完全
                TypeArray   *p,                     // 配列
                BYTE        buf[],                  // バッファー
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Copy」は、コピーするを意味し!ココでワザワザ
「MoveCopy」と表現したのは、少し前で紹介した
関数「MoveArrayBYTE ()」では、コピーする時間を
省略する為に工夫≪中身をコピーする替わりにポインタの値
を関数辺値とし返した≫していましたが、この関数は同じ型
で有っても実際にコピーします!
「Array」は、「TypeArray型」を意味し!
「Byte 」は、「BYTE型」のデータ配列を意味します!
英単語先頭大文字続く部分を小文字で切れ目表現に注意!
仮引数「TypeArray* p,」の形で格納されたデータを
仮引数「BYTE buf[],int size」の「BYTE型」のデータ配列
とサイズを示したC言語で扱い易い形に移動する為の関数で
す!
関数の返値は、実際にコピー動作したサイズを整数値で
返します!但し、仮引数「TypeArray* p,」で示した
画像情報が不適合ならばエラーコード「STI_ARY_0」を
返します!
★詳細★は、後で説明:【ファイル「CopyClear000.cpp」が
対象】します!

(4-11-8)関数「int MoveCopyArrayShort (
TypeArray* p,short buf[],int size);」

    int     MoveCopyArrayShort(                     // 配列→buf:short:完全
                TypeArray   *p,                     // 配列
                short       buf[],                  // バッファー
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Copy」は、コピーするを意味し!ココでワザワザ
「MoveCopy」と表現したのは、少し前で紹介した
関数「MoveArrayshort ()」では、コピーする時間を
省略する為に工夫していましたが、この関数は同じ型で
有ってもコピーします!
「Array」は、「TypeArray型」を意味し!
「Short 」は、「short型」のデータ配列を意味します!
英単語先頭大文字続く部分を小文字で切れ目表現に注意!
仮引数「TypeArray* p,」の形で格納されたデータを
仮引数「short buf[],int size」の「short型」の
データ配列とサイズを示したC言語で扱い易い形に移動する
為の関数です!
関数の返値は、実際にコピー動作したサイズを整数値で
返します!但し、仮引数「TypeArray* p,」で示した
画像情報が不適合ならばエラーコード「STI_ARY_0」を
返します!
★詳細★は、後で説明:【ファイル「CopyClear000.cpp」が
対象】します!

(4-11-9)関数「int MoveCopyArrayLong (
TypeArray* p,long buf[],int size);」

    int     MoveCopyArrayLong(                      // 配列→buf:long:完全
                TypeArray   *p,                     // 配列
                long        buf[],                  // バッファー
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Copy」は、コピーするを意味し!ココでワザワザ
「MoveCopy」と表現したのは、少し前で紹介した
関数「MoveArrayshort ()」では、コピーする時間を
省略する為に工夫していましたが、この関数は同じ型で
有ってもコピーします!
「Array」は、「TypeArray型」を意味し!
「long 」は、「long型」のデータ配列を意味します!
仮引数「TypeArray* p,」の形で格納されたデータを
仮引数「long buf[],int size」の「long型」の
データ配列とサイズを示したC言語で扱い易い形に移動する
為の関数です!
関数の返値は、実際にコピー動作したサイズを整数値で
返します!但し、仮引数「TypeArray* p,」で示した
画像情報が不適合ならばエラーコード「STI_ARY_0」を
返します!

(4-11-10)関数「int MoveCopyArrayInt (
TypeArray* p,int buf[],int size);」

    int     MoveCopyArrayInt(                       // 配列→buf:int:完全
                TypeArray   *p,                     // 配列
                int         buf[],                  // バッファー
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Copy」は、コピーするを意味し!ココでワザワザ
「MoveCopy」と表現したのは、少し前で紹介した
関数「MoveArrayshort ()」では、コピーする時間を
省略する為に工夫していましたが、この関数は同じ型で
有ってもコピーします!
「Array」は、「TypeArray型」を意味し!
「int 」は、「int型」のデータ配列を意味します!
仮引数「TypeArray* p,」の形で格納されたデータを
仮引数「int buf[],int size」の「int型」の
データ配列とサイズを示したC言語で扱い易い形に移動する
為の関数です!
関数の返値は、実際にコピー動作したサイズを整数値で
返します!但し、仮引数「TypeArray* p,」で示した
画像情報が不適合ならばエラーコード「STI_ARY_0」を
返します!

(4-11-11)関数「int MoveCopyArrayFloat(
TypeArray* p,float buf[],int size);」

    int     MoveCopyArrayFloat(                     // 配列→buf:float:完全
                TypeArray   *p,                     // 配列
                float       buf[],                  // バッファー
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Copy」は、コピーするを意味し!ココでワザワザ
「MoveCopy」と表現したのは、少し前で紹介した
関数「MoveArrayshort ()」では、コピーする時間を
省略する為に工夫していましたが、この関数は同じ型で
有ってもコピーします!
「Array」は、「TypeArray型」を意味し!
「Float」は、「float型」のデータ配列を意味します!
英単語先頭大文字続く部分を小文字で切れ目表現に注意!
仮引数「TypeArray* p,」の形で格納されたデータを
仮引数「float buf[],floatsize」の「float型」の
データ配列とサイズを示したC言語で扱い易い形に移動する
為の関数です!
関数の返値は、実際にコピー動作したサイズを整数値で
返します!但し、仮引数「TypeArray* p,」で示した
画像情報が不適合ならばエラーコード「STI_ARY_0」を
返します!

(4-11-12)関数「int MoveCopyArrayDouble (
TypeArray* p,double buf[],int size);」

    int     MoveCopyArrayDouble(                    // 配列→buf:double:完全
                TypeArray   *p,                     // 配列
                double      buf[],                  // バッファー
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Copy」は、コピーするを意味し!ココでワザワザ
「MoveCopy」と表現したのは、少し前で紹介した
関数「MoveArrayshort ()」では、コピーする時間を
省略する為に工夫していましたが、この関数は同じ型で
有ってもコピーします!
「Array」は、「TypeArray型」を意味し!
「Double 」は、「double 型」のデータ配列を意味します!
英単語先頭大文字続く部分を小文字で切れ目表現に注意!
仮引数「TypeArray* p,」の形で格納されたデータを
仮引数「double buf[],double size」の「double 型」の
データ配列とサイズを示したC言語で扱い易い形に移動する
為の関数です!
関数の返値は、実際にコピー動作したサイズを整数値で
返します!但し、仮引数「TypeArray* p,」で示した
画像情報が不適合ならばエラーコード「STI_ARY_0」を
返します!

(4-11-13)関数「int MoveByteArray(
BYTE buf[],TypeArray* p,int size);」

    int     MoveByteArray(                          // Buf→配列:BYTE
                BYTE        buf[],                  // バッファー
                TypeArray   *p,                     // 配列
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Byte 」は、「BYTE型」のデータ配列を意味します!
英単語先頭大文字続く部分を小文字で切れ目表現に注意!
「Array」は、「TypeArray型」を意味し!
仮引数「BYTE buf[],int size」の「BYTE型」のデータ配列
とサイズを示したC言語で扱い易い形の中身のデータを
仮引数「TypeArray* p,」の形で格納(中身をコピー)する
事を行う関数です!
関数の返値は、正常に動作完了は「END_STI」を返し、
仮引数「TypeArray* p,」が適合シナカッタ場合は、
エラーコードを返します!
★詳細★は、後で説明:【ファイル「CopyClear000.cpp」が
対象】します!

(4-11-14)関数「int MoveShort Array(
short buf[],TypeArray* p,int size);」

    int     MoveShortArray(                         // Buf→配列:short
                short       buf[],                  // バッファー
                TypeArray   *p,                     // 配列
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Short 」は、「short型」のデータ配列を意味します!
英単語先頭大文字続く部分を小文字で切れ目表現に注意!
「Array」は、「TypeArray型」を意味し!
仮引数「short buf[],int size」の「short型」の
データ配列とサイズを示したC言語で扱い易い形の中身の
データを仮引数「TypeArray* p,」の形で格納(中身を
コピー)する事を行う関数です!
関数の返値は、正常に動作完了は「END_STI」を返し、
仮引数「TypeArray* p,」が適合シナカッタ場合は、
エラーコードを返します!
★詳細★は、後で説明:【ファイル「CopyClear000.cpp」が
対象】します!

(4-11-15)関数「int MovelongArray(
long buf[],TypeArray* p,int size);」

    int     MoveLongArray(                          // Buf→配列:long
                long        buf[],                  // バッファー
                TypeArray   *p,                     // 配列
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「long 」は、「long型」のデータ配列を意味します!
英単語先頭大文字続く部分を小文字で切れ目表現に注意!
「Array」は、「TypeArray型」を意味し!
仮引数「long buf[],int size」の「long型」のデータ配列
とサイズを示したC言語で扱い易い形の中身のデータを
仮引数「TypeArray* p,」の形で格納(中身をコピー)する
事を行う関数です!
関数の返値は、正常に動作完了は「END_STI」を返し、
仮引数「TypeArray* p,」が適合シナカッタ場合は、
エラーコードを返します!
★詳細★は、後で説明:【ファイル「CopyClear000.cpp」が
対象】します!

(4-11-16)関数「int MoveIntArray(
int buf[],TypeArray* p,int size);」

    int     MoveIntArray(                           // Buf→配列:int
                int         buf[],                  // バッファー
                TypeArray   *p,                     // 配列
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「int 」は、「int型」のデータ配列を意味します!
英単語先頭大文字続く部分を小文字で切れ目表現に注意!
「Array」は、「TypeArray型」を意味し!
仮引数「int buf[],int size」の「int型」のデータ配列
とサイズを示したC言語で扱い易い形の中身のデータを
仮引数「TypeArray* p,」の形で格納(中身をコピー)する
事を行う関数です!
関数の返値は、正常に動作完了は「END_STI」を返し、
仮引数「TypeArray* p,」が適合シナカッタ場合は、
エラーコードを返します!
★詳細★は、後で説明:【ファイル「CopyClear000.cpp」が
対象】します!

(4-11-17)関数「int MoveFloatArray(
float buf[],TypeArray* p,int size);」

    int     MoveFloatArray(                         // Buf→配列:float
                float       buf[],                  // バッファー
                TypeArray   *p,                     // 配列
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Float」は、「float型」のデータ配列を意味します!
英単語先頭大文字続く部分を小文字で切れ目表現に注意!
「Array」は、「TypeArray型」を意味し!
仮引数「float buf[],float size」の「float型」の
データ配列とサイズを示したC言語で扱い易い形の中身の
データを仮引数「TypeArray* p,」の形で格納(中身を
コピー)する事を行う関数です!
関数の返値は、正常に動作完了は「END_STI」を返し、
仮引数「TypeArray* p,」が適合シナカッタ場合は、
エラーコードを返します!
★詳細★は、後で説明:【ファイル「CopyClear000.cpp」が
対象】します!

(4-11-18)関数「int MoveDoubleArray(
double buf[],TypeArray* p,int size);」

    int     MoveDoubleArray(                        // Buf→配列:double
                double      buf[],                  // バッファー
                TypeArray   *p,                     // 配列
                int         size                    // サイズ
            );

「Move」は、移動するを意味し!
「Double 」は、「double 型」のデータ配列を意味します!
英単語先頭大文字続く部分を小文字で切れ目表現に注意!
「Array」は、「TypeArray型」を意味し!
仮引数「double buf[],double size」の「double 型」の
データ配列とサイズを示したC言語で扱い易い形の中身の
データを仮引数「TypeArray* p,」の形で格納(中身を
コピー)する事を行う関数です!
関数の返値は、正常に動作完了は「END_STI」を返し、
仮引数「TypeArray* p,」が適合シナカッタ場合は、
エラーコードを返します!
★詳細★は、後で説明:【ファイル「CopyClear000.cpp」が
対象】します!

(4-11-19)関数「int ClearRoundImageBase(
TypeArray* pa,int data,int n1,int n2);」

    int     ClearRoundImageBase(                    // 周囲クリア:基本
                TypeArray   *pa,                    // 配列
                int         data,                   // データ:整数
                int         n1,                     // 水平線クリア回数
                int         n2                      // 垂直線クリア回数
            );

「Clear」は、英単語「Clear」でカタカナ語でもクリアー
として「きれいに成る・片付ける」、
この画像処理ライブラリでは、「同じデータを画像メモリ
の画素に書き込んで同じ値にする事で一番多い例では
【0を書き込む】事で【0クリア】を行う」を意味します!
「Round」は、英単語「Round」、日本語としては
「一回り・一巡」、周囲一回りを意味します!
「Image」は、勿論、画像を意味し!
「Base」は、基本を意味し!
仮引数「int data」で整数型の数値を書き込む(クリアする
)値として指定します!
この画像処理ライブラリでは、「周囲=画像メモリの
外枠的な最外周」をクリアする基本関数を意味します!
仮引数「int n1,int n2」と水平線のクリア本数と垂直線の
クリア本数と縦横別に指定出来る事も特徴!
★備考★何故、この画像の周囲をクリアする処理が必要かは
クラス【class Filter:public Calculate{}】の解説を行う
ところで説明します!
★注意★同じ型名でオーバーロード(多重定義)関数として
仮引数「double data」で浮動小数点数型を示す型の数値を
書き込む(クリアする)値として指定する関数も存在!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!
注意★解説『解説クラスFilter(1)』等で

(4-11-20)関数「int ClearRoundImageBase(
TypeArray* pa,double data,int n1,int n2);」

    int     ClearRoundImageBase(                    // 周囲クリア:基本
                TypeArray   *pa,                    // 配列
                double      data,                   // データ:実数
                int         n1,                     // 水平線クリア回数
                int         n2                      // 垂直線クリア回数
            );

「Clear」は、英単語「Clear」でカタカナ語でもクリアー
として「きれいに成る・片付ける」、
この画像処理ライブラリでは、「同じデータを画像メモリの
画素に書き込んで同じ値にする事で一番多い例では
【0を書き込む】事で【0クリア】を行う」を意味します!
「Round」は、英単語「Round」、日本語としては
「一回り・一巡」、周囲一回りを意味します!
「Image」は、勿論、画像を意味し!
「Base」は、基本を意味し!
仮引数「double data」で倍精度浮動小数点数型の数値を
書き込む(クリアする)値として指定します!
この画像処理ライブラリでは、「周囲=画像メモリの外枠的
な最外周」をクリアする基本関数を意味します!
仮引数「int n1,int n2」と水平線のクリア本数と垂直線の
クリア本数と縦横別に指定出来る事も特徴!
★備考★何故、この画像の周囲をクリアする処理が必要かは
クラス【class Filter:public Calculate{}】の解説を行う
ところで説明します!
★注意★同じ型名でオーバーロード(多重定義)関数として
仮引数「int data」で整数型を示す型の数値を書き込む(
クリアする)値として指定する関数も存在!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-11-21)関数「int ClearRoundImage(
TypeArray* pa,double data,int n);」

    int     ClearRoundImage(                        // 周囲クリア
                TypeArray   *pa,                    // 配列
                int         data,                   // データ:整数
                int         n                       // クリア周回回数
            );

「Clear」は、英単語「Clear」でカタカナ語でもクリアー
として「きれいに成る・片付ける」、
この画像処理ライブラリでは、「同じデータを画像メモリの
画素に書き込んで同じ値にする事で一番多い例では
【0を書き込む】事で【0クリア】を行う」を意味します!
「Round」は、英単語「Round」、日本語としては
「一回り・一巡」、周囲一回りを意味します!
「Image」は、勿論、画像を意味し!
仮引数「int data」で整数型の数値を書き込む(クリアする
)値として指定します!
この画像処理ライブラリでは、「周囲=画像メモリの外枠的
な最外周」をクリアする関数を意味します!
基本関数「ClearRoundImageBase()」との違いは、
仮引数「int n」と周回数だけ指定し、水平線/垂直線と
分けて居ません!
★備考★何故、この画像の周囲をクリアする処理が必要かは
クラス【class Filter:public Calculate{}】の解説を行う
ところで説明します!
★注意★同じ型名でオーバーロード(多重定義)関数として
仮引数「double data」で浮動小数点数型を示す型の数値を
書き込む(クリアする)値として指定する関数も存在!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-11-22)関数「int ClearRoundImage(
TypeArray* pa,double data,int n);」

    int     ClearRoundImage(                        // 周囲クリア
                TypeArray   *pa,                    // 配列
                double      data,                   // データ:実数
                int         n                       // クリア周回回数
            );

「Clear」は、英単語「Clear」でカタカナ語でもクリアー
として「きれいに成る・片付ける」、
この画像処理ライブラリでは、「同じデータを画像メモリの
画素に書き込んで同じ値にする事で一番多い例では
【0を書き込む】事で【0クリア】を行う」を意味します!
「Round」は、英単語「Round」、日本語としては
「一回り・一巡」、周囲一回りを意味します!
「Image」は、勿論、画像を意味し!
仮引数「double data」で倍精度浮動小数点数型の数値を
書き込む(クリアする)値として指定します!
この画像処理ライブラリでは、「周囲=画像メモリの外枠的
な最外周」をクリアする関数を意味します!
基本関数「ClearRoundImageBase()」との違いは、
仮引数「int n」と周回数だけ指定し、水平線/垂直線と
分けて居ません!
★備考★何故、この画像の周囲をクリアする処理が必要かは
クラス【class Filter:public Calculate{}】の解説を行う
ところで説明します!
★注意★同じ型名でオーバーロード(多重定義)関数として
仮引数「int data」で整数型を示す型の数値を書き込む(
クリアする)値として指定する関数も存在!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-11-23)関数「int CopyRoundImage(
TypeArray* ps,TypeArray* pd,int n);」

    int     CopyRoundImage(                         // 周囲転送
                TypeArray   *ps,                    // S配列
                TypeArray   *pd,                    // D配列
                int         n                       // コピー周回回数
            );

「Copy」は、コピーするを意味し!
「Round」は、英単語「Round」、日本語としては
「一回り・一巡」、周囲一回りを意味します!
「Image」は、勿論、画像を意味し!
「CopyRoundImage」で
仮引数「TypeArray* ps,」の元画像から
仮引数「TypeArray* pd,」の結果画像へ、周囲一回りを
コピーする関数です!
仮引数「int n」と周回数だけ指定し、水平線/垂直線と
分けて居ません!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-11-24)関数「int CopyRoundImageBase(
TypeArray* ps,TypeArray* pd,int n1,int n2);」

    int     CopyRoundImageBase(                     // 周囲転送:基本
                TypeArray   *ps,                    // S配列
                TypeArray   *pd,                    // D配列
                int         n1,                     // 水平線コピー回数
                int         n2                      // 垂直線コピー回数
            );

「Copy」は、コピーするを意味し!
「Round」は、英単語「Round」、日本語としては
「一回り・一巡」、周囲一回りを意味します!
「Image」は、勿論、画像を意味し!
「Base」は、基本を意味し!
「CopyRoundImageBase」で
仮引数「TypeArray* ps,」の元画像から
仮引数「TypeArray* pd,」の結果画像へ、周囲一回りを
コピーする関数です!
仮引数「int n1,int n2」と水平線のコピー本数と
垂直線のコピー本数と縦横別に指定出来る事も特徴!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-11-25)関数「int MagnifyZoom(
TypeArray* ps,TypeArray* pd,
double zh,double zv,int dataSize=1);」

    int             MagnifyZoom(                    // 拡大・縮小
        TypeArray   *ps,                            // S配列
        TypeArray   *pd,                            // D配列
        double      zh,                             // 水平拡大率
        double      zv,                             // 垂直拡大率
        int         dataSize=1 );                   // 画素サイズ(省略時=1)

「Magnify」は、英単語「magnify」で「拡大」を意味します
「Zoom」は、画像処理ですので画像の拡大ですが拡大の
意味を拡大解釈して画像の拡大・縮小を行う関数です!
仮引数「TypeArray* ps,」は、元画像(S)
仮引数「TypeArray* pd,」は、結果画像(D)
仮引数「double zh,」は、水平方向(X軸方向)の拡大(
縮尺)率と倍精度浮動小数点数で指定!
仮引数「double zv,」は、垂直方向(Y軸方向)の拡大(
縮尺)率と倍精度浮動小数点数で指定!★注意★「zh,zv」
の「z」は、英語「Camerazoom」の略として「z」で表現
元々は、オノマトペ(多分「ズー音」)らしい?!
カメラレンズの動作音から来たと思える!その為に
関数名「magnify」と意味が有る物を使用し引数に「z」を
使用しました!
仮引数「int dataSize=1,」は、通常省略時(dataSize=1)
で1画素単位処理ですが、BMP構造も処理出来る様にした
事でBMPならば、(dataSize=3)としてカラー画像を
処理します!
★詳細★は、後で説明:【ファイル「CopyClear300.cpp」が
対象】します!

(4-11-26)関数「int MagnifyZoomint(
TypeArray* ps,TypeArray* pd,
int zh,int zv,int dataSize=1);」

    int             MagnifyZoomInt(                 // 整数倍拡大
        TypeArray   *ps,                            // S配列
        TypeArray   *pd,                            // D配列
        int         zh,                             // 水平拡大率
        int         zv,                             // 垂直拡大率
        int         dataSize=1 );                   // 画素サイズ(省略時=1)

「Magnify」は、英単語「magnify」で「拡大」を意味します
「Zoom」は、画像処理ですので画像の拡大ですが拡大の
意味を拡大解釈して画像の拡大・縮小を行う関数です!
仮引数「TypeArray* ps,」は、元画像(S)
仮引数「TypeArray* pd,」は、結果画像(D)
仮引数「int zh,」は、水平方向(X軸方向)の拡大(
整数倍)率と整数型で指定!
仮引数「int zv,」は、垂直方向(Y軸方向)の拡大(
整数倍)率と整数型で指定!関数名「int 」は特に分かる
様に命名しています!
★注意★「zh,zv」の「z」は、英語「Camerazoom」の略
として「z」で表現元々は、オノマトペ(多分「ズー音」)
らしい?!
カメラレンズの動作音から来たと思える!その為に
関数名「magnify」と意味が有る物を使用し引数に「z」を
使用しました!
仮引数「int dataSize=1,」は、通常省略時(dataSize=1)
で1画素単位処理ですが、BMP構造も処理出来る様にした
事でBMPならば、(dataSize=3)としてカラー画像を
処理します!
★詳細★は、後で説明:【ファイル「CopyClear300.cpp」が
対象】します!

(4-11-27)関数「int MagnifyZoomInterpolate(
TypeArray* ps,TypeArray* pd,
double zh,double zv,
double offsetX=0.0,double offsetY=0.0,
int dataSize=1);」

    int             MagnifyZoomInterpolate(         // 拡大・縮小:補間
        TypeArray   *ps,                            // S配列
        TypeArray   *pd,                            // D配列
        double      zh,                             // 水平拡大率
        double      zv,                             // 垂直拡大率
        double      offsetX=0.0,                    // 微少X座標オフセット
        double      offsetY=0.0,                    // 微少Y座標オフセット
        int         dataSize=1 );                   // 画素サイズ(省略時=1)

「MagnifyZoom」は、関数「MagnifyZoom()」で説明した
様に画像の拡大/縮小です!
「Interpolate」は、英単語「Interpolate」で
「補間する」を意味します!関数「MagnifyZoom()」では
例えば、縦横2倍拡大「MagnifyZoom(s,d,2,2);」を実行す
ると同じ画素の値を拡大した結果画像の方で元の画像を縦横
4画素が同じ値として格納しますが、
関数「MagnifyZoomInterpolate()」では、座標の値の
割合に応じて、書き込む画素の値を拡大してもジグザグ感を
感じ無い様に補間して書き込みます!★注意★勿論、単純な
拡大/縮小関数「MagnifyZoom()」依りも補完する為に
処理時間を余計に掛ける事に注意して下さい!
★詳細★は、後で説明:【ファイル「CopyClear300.cpp」が
対象】します!

(4-11-28)関数「int
MagnifyZoomInterpolateByte (
TypeArray* ps,TypeArray* pd,
double zh,double zv,
double offsetX=0.0,double offsetY=0.0,int dataSize=1);」

      int             MagnifyZoomInterpolateByte(     // 拡大・縮小:補間:BYTE専用
        TypeArray   *ps,                            // S配列
        TypeArray   *pd,                            // D配列
        double      zh,                             // 水平拡大率
        double      zv,                             // 垂直拡大率
        double      offsetX=0.0,                    // 微少X座標オフセット
        double      offsetY=0.0,                    // 微少Y座標オフセット
        int         dataSize=1 );                   // 画素サイズ(省略時=1)  

関数「MagnifyZoomInterpolate()」の
「BYTE 」と画素単位が1バイト整数型画素専用の
関数です!
★注意★関数「MagnifyZoomInterpolate()」の
サブルーチンとして作成しましたので他の型の物も作成して
いますが、この「BYTE 」が付いて居る関数だけ
「public:」属性を付けています!
使用頻度が多いからです!
★詳細★は、後で説明:【ファイル「CopyClear300.cpp」が
対象】します!

(4-11-29)関数「int MagnifyAverage(
TypeArray* ps,TypeArray* pd,
int zh,int zv,int sw=FALSE);」

    int             MagnifyAverage(                 // 縮小:平均化
        TypeArray   *ps,                            // S配列
        TypeArray   *pd,                            // D配列
        int         zh,                             // 水平縮小率 1,2,3,4...16
        int         zv,                             // 垂直縮小率 1,2,3,4...16
        int         sw=FALSE );                     // sw=偽(省略時:平均)、真→合計

「Magnify」は、英単語「magnify」でここでは「拡大」
で無く「縮小」を意味します!
「Average」は、勿論英単語で「平均値」を意味します!
仮引数「int sw=FALSE」で省略時(sw=FALSE)の時に
幾何学的に縮小した画像の画素を平均して書き込みます!
そして「sw=TRUE」の時は、合計値にして書き込む事が
特徴です!
★詳細★は、後で説明:【ファイル「CopyClear300.cpp」が
対象】します!

(4-11-30)関数「int MoveImageByte (
TypeArray* ps,TypeArray* pd,
double offsetX,double offsetY,int dataSize=1);」

    int             MoveImageByte(                  // 平行移動:補間:BYTE
        TypeArray*  ps,                             // S配列
        TypeArray*  pd,                             // D配列
        double      offsetX,                        // X座標(0.0~1.0)
        double      offsetY,                        // Y座標(0.0~1.0)
        int         dataSize=1 );                   // 画素サイズ

「Move」は、移動するを意味し!
「ImageBYTE 」は、「BYTE型」単位画像を示し!
幾何変換としての平行移動の「BYTE型」単位画像用
サブルーチンです!
★詳細★は、後で説明:【ファイル「CopyClear350.cpp」が
対象】します!

(4-11-31)関数「int MoveImageShort (
TypeArray* ps,TypeArray* pd,
double offsetX,double offsetY,int dataSize=1);」

    int             MoveImageShort(                 // 平行移動:補間:short
        TypeArray*  ps,                             // S配列
        TypeArray*  pd,                             // D配列
        double      offsetX,                        // X座標(0.0~1.0)
        double      offsetY,                        // Y座標(0.0~1.0)
        int         dataSize=1 );                   // 画素サイズ

「Move」は、移動するを意味し!
「ImageShort 」は、「short型」単位画像を示し!
幾何変換としての平行移動の「short型」単位画像用
サブルーチンです!
★詳細★は、後で説明:【ファイル「CopyClear350.cpp」が
対象】します!

(4-11-32)関数「int MoveImageLong (
TypeArray* ps,TypeArray* pd,
double offsetX,double offsetY,int dataSize=1);」

    int             MoveImageLong(                  // 平行移動:補間:long
        TypeArray*  ps,                             // S配列
        TypeArray*  pd,                             // D配列
        double      offsetX,                        // X座標(0.0~1.0)
        double      offsetY,                        // Y座標(0.0~1.0)
        int         dataSize=1 );                   // 画素サイズ

「Move」は、移動するを意味し!
「ImageLong 」は、「long型」単位画像を示し!
幾何変換としての平行移動の「long型」単位画像用
サブルーチンです!
★詳細★は、後で説明:【ファイル「CopyClear350.cpp」が
対象】します!

(4-11-33)関数「int MoveImageFloat(
TypeArray* ps,TypeArray* pd,
double offsetX,double offsetY,int dataSize=1);」

    int             MoveImageFloat(                 // 平行移動:補間:単精度
        TypeArray*  ps,                             // S配列
        TypeArray*  pd,                             // D配列
        double      offsetX,                        // X座標(0.0~1.0)
        double      offsetY,                        // Y座標(0.0~1.0)
        int         dataSize=1 );                   // 画素サイズ

「Move」は、移動するを意味し!
「ImageFloat」は、「float型」単位画像を示し!
幾何変換としての平行移動の「float型」単位画像用
サブルーチンです!
★詳細★は、後で説明:【ファイル「CopyClear350.cpp」が
対象】します!

(4-11-34)関数「int SetMathematics(int sw);」

    int     SetMathematics(                         // 数学的設定
                int     sw                          // 0:degree/1:radian
            );

「Set」は、カタカナ語セットするとして
「Mathematics」は、英単語「Mathematics」で
数学です!ここでは、数学的なパラメータとして
関数で使用する角度を
仮引数「int sw」が、
「0:degree」⇒「度数(0~360°)」
「1:radian」⇒「ラジアン(0~2π)
で指定する事を意味します!
★注意★他の数学的なパラメータも考えたのだが、
ここでは、度数/ラジアン切り替えだけです!

★備考★
解説『解説クラスTypeArray』でも記載したが、
noteエディタの変な特性でコピペした文章の半角「*」
が消されたり、空白「 」が消される事が多々あります!
注意して手作業で修正している筈ですが、必ず、code
機能で表示して居る物を正しいとして確認して下さい

ここで一旦、切れが良い「元々サブルーチンとして作成
作成した【private属性】を付けていたが【public】属性
に変更した関数紹介が終わったので3月3日分迄の
講義とします!

続きは、「解説クラスCopyClear(8)」に成り
ます!
「(8)」では、サブルーチンとして作成した
【private属性】の関数の紹介と【protected】属性の
束縛変数に付いて紹介します!
引き続き御贔屓して受講して下さい!

文末


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