見出し画像

解説クラスCopyClear(8)

解説クラスCopyClear(8)


2024年3月4初講(初稿)

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

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

private:
    void    clear_1(                                // クリア:BYTE
                TypeArray   *pa,                    //  配列
                int         data );                 //  データ
    void    clear_2(                                // クリア:2BYTE
                TypeArray   *pa,                    //  配列
                int         data );                 //  データ
    void    clear_4(                                // クリア:4BYTE
                TypeArray   *pa,                    //  配列
                int         data );                 //  データ
    void    clear_float(                            // クリア:float
                TypeArray   *pa,                    //  配列
                double      data );                 //  データ
    void    clear_double(                           // クリア:double
                TypeArray   *pa,                    //  配列
                double      data );                 //  データ

    int     ClearRoundImageOnece(                   // 周囲クリア:1周
                int     adr,                        // 画像の左上Adr
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     w,                          // 画素の単位
                int     data );                     // データ:整数
    int     ClearRoundImageOnece(                   // 周囲クリア:1周
                int     adr,                        // 画像の左上Adr
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     w,                          // 画素の単位
                double  data );                     // データ:実数
    int     ClearRoundImageHV(                      // 周囲クリア:指定回数
                int     adr,                        // 画像の左上Adr
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     w,                          // 画素の単位
                int     data,                       // データ:整数
                int     n1,                         // 水平線クリア回数
                int     n2 );                       // 垂直線クリア回数
    int     ClearRoundImageHV(                      // 周囲クリア:指定回数
                int     adr,                        // 画像の左上Adr
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     w,                          // 画素の単位
                double  data,                       // データ:実数
                int     n1,                         // 水平線クリア回数
                int     n2 );                       // 垂直線クリア回数

    void    clear_round_byte_h(                     // 周囲クリア:BYTE:上下辺
                BYTE    *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data );                     // データ
    void    clear_round_byte_v(                     // 周囲クリア:BYTE:左右辺
                BYTE    *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data );                     // データ
    void    clear_round_byte(                       // 周囲クリア:BYTE
                BYTE    *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data,                       // データ
                int     n1,                         // 水平線クリア回数
                int     n2 );                       // 垂直線クリア回数
    void    clear_round_short_h(                    // 周囲クリア:short:上下辺
                short   *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data );                     // データ
    void    clear_round_short_v(                    // 周囲クリア:short:左右辺
                short   *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data );                     // データ
    void    clear_round_short(                      // 周囲クリア:short
                short   *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data,                       // データ
                int     n1,                         // 水平線クリア回数
                int     n2 );                       // 垂直線クリア回数
    void    clear_round_long_h(                     // 周囲クリア:long:上下辺
                long    *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data );                     // データ
    void    clear_round_long_v(                     // 周囲クリア:long:左右辺
                long    *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data );                     // データ
    void    clear_round_long(                       // 周囲クリア:long
                long    *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data,                       // データ
                int     n1,                         // 水平線クリア回数
                int     n2 );                       // 垂直線クリア回数
    void    clear_round_float(                      // 周囲クリア:float
                float   *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                double  data,                       // データ
                int     n1,                         // 水平線クリア回数
                int     n2 );                       // 垂直線クリア回数
    void    clear_round_double_h(                   // 周囲クリア:double:上下辺
                double  *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                double  data );                     // データ
    void    clear_round_double_v(                   // 周囲クリア:double:左右辺
                double  *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                double  data );                     // データ
    void    clear_round_double(                     // 周囲クリア:double
                double  *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                double  data,                       // データ
                int     n1,                         // 水平線クリア回数
                int     n2 );                       // 垂直線クリア回数
    void    copy_byte_short(                        // 転送:BYTE→short
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_byte_int(                          // 転送:BYTE→int
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_byte_float(                        // 転送:BYTE→float
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_byte_double(                       // 転送:BYTE→double
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_short_byte(                        // 転送:short→BYTE
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_short_int(                         // 転送:short→int
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_short_float(                       // 転送:short→float
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_short_double(                      // 転送:short→double
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_int_byte(                          // 転送:int→BYTE
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_int_short(                         // 転送:int→short
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_int_float(                         // 転送:int→float
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_int_double(                        // 転送:int→double
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_float_byte(                        // 転送:float→BYTE
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_float_short(                       // 転送:float→short
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_float_int(                         // 転送:float→int
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_float_double(                      // 転送:float→double
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_double_byte(                       // 転送:double→BYTE
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_double_short(                      // 転送:double→short
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_double_int(                        // 転送:double→int
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列
    void    copy_double_float(                      // 転送:double→float
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

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

(4-12-1)関数「void clear_1(
TypeArray* pa,int data);」

    void    clear_1(                                // クリア:BYTE
                TypeArray   *pa,                    //  配列
                int         data );                 //  データ

関数「Clear()」のサブルーチンで
仮引数「TypeArray* pa,」の画素単位が1バイト整数の
場合用の関数です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-2)関数「void clear_2(
TypeArray* pa,int data);」

    void    clear_2(                                // クリア:2BYTE
                TypeArray   *pa,                    //  配列
                int         data );                 //  データ

関数「Clear()」のサブルーチンで
仮引数「TypeArray* pa,」の画素単位が2バイト整数の
場合用の関数です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-4)関数「void clear_4(
TypeArray* pa,int data);」

    void    clear_4(                                // クリア:4BYTE
                TypeArray   *pa,                    //  配列
                int         data );                 //  データ

関数「Clear()」のサブルーチンで
仮引数「TypeArray* pa,」の画素単位が4バイト整数の
場合用の関数です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-3)関数「void clear_float(
TypeArray* pa,double data);」

    void    clear_float(                            // クリア:float
                TypeArray   *pa,                    //  配列
                double      data );                 //  データ

関数「Clear()」のサブルーチンで
仮引数「TypeArray* pa,」の画素単位が
単精度浮動小数点数型の場合用の関数です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-4)関数「void clear_double(
TypeArray* pa,double data);」

    void    clear_double(                           // クリア:double
                TypeArray   *pa,                    //  配列
                double      data );                 //  データ

関数「Clear()」のサブルーチンで
仮引数「TypeArray* pa,」の画素単位が
倍精度浮動小数点数型の場合用の関数です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-5)関数「int ClearRoundImageOnece(
int adr,int h,int v,int inc,int w,int data);」

    int     ClearRoundImageOnece(                   // 周囲クリア:1周
                int     adr,                        // 画像の左上Adr
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     w,                          // 画素の単位
                int     data );                     // データ:整数

関数「ClearRoundImage()」のサブルーチンです!
「Onece」は、英単語「Onece」で「一度・一回」との
意味でココでは、外周1回用です!
書き込むデータは、仮引数「int data」整数型です!
★注意★オーバーロード(多重定義)関数として同名で
仮引数「double data」の関数も存在!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-6)関数「int ClearRoundImageOnece(
int adr,int h,int v,int inc,int w,double data);」

    int     ClearRoundImageOnece(                   // 周囲クリア:1周
                int     adr,                        // 画像の左上Adr
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     w,                          // 画素の単位
                double  data );                     // データ:実数

関数「ClearRoundImage()」のサブルーチンです!
「Onece」は、英単語「Onece」で「一度・一回」との
意味でココでは、外周1回用です!
書き込むデータは、仮引数「double data」倍精度浮動
小数点数数型です!
★注意★オーバーロード(多重定義)関数として同名で
仮引数「int data」の関数も存在!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-7)関数「int ClearRoundImageHV(
int adr,int h,int v,int inc,int w,int data,
int n1,int n2);」

    int     ClearRoundImageHV(                      // 周囲クリア:指定回数
                int     adr,                        // 画像の左上Adr
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     w,                          // 画素の単位
                int     data,                       // データ:整数
                int     n1,                         // 水平線クリア回数
                int     n2 );                       // 垂直線クリア回数

関数「ClearRoundImage()」のサブルーチンです!
「HV」は、水平線・垂直線の幅サイズを意味します!
書き込むデータは、仮引数「int data」整数型です!
★注意★オーバーロード(多重定義)関数として同名で
仮引数「double data」の関数も存在!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-8)関数「int ClearRoundImageHV(
int adr,int h,int v,int inc,int w,double data,
int n1,int n2);」

    int     ClearRoundImageHV(                      // 周囲クリア:指定回数
                int     adr,                        // 画像の左上Adr
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     w,                          // 画素の単位
                double  data,                       // データ:実数
                int     n1,                         // 水平線クリア回数
                int     n2 );                       // 垂直線クリア回数

関数「ClearRoundImage()」のサブルーチンです!
「HV」は、水平線・垂直線の幅サイズを意味します!
書き込むデータは、仮引数「double data」実数型です!
★注意★オーバーロード(多重定義)関数として同名で
仮引数「int data」の関数も存在!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-9)関数「void clear_round_byte_h(
BYTE *p,int h,int v,int inc,int data);」

    void    clear_round_byte_h(                     // 周囲クリア:BYTE:上下辺
                BYTE    *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data );                     // データ

関数「ClearRoundImage()」のサブルーチンです!
「byte_h」は、「BYTE型」で水平線≪具体的には画像の
最上辺・最下辺≫処理用です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-10)関数「void clear_round_byte_v(
BYTE *p,int h,int v,int inc,int data);」

    void    clear_round_byte_v(                     // 周囲クリア:BYTE:左右辺
                BYTE    *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data );                     // データ

関数「ClearRoundImage()」のサブルーチンです!
「byte_v」は、「BYTE型」で垂直線≪具体的には画像の
最右辺・最左辺≫処理用です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-11)関数「void clear_round_byte(
BYTE *p,int h,int v,int inc,int data,
int n1,int n2);」

    void    clear_round_byte(                       // 周囲クリア:BYTE
                BYTE    *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data,                       // データ
                int     n1,                         // 水平線クリア回数
                int     n2 );                       // 垂直線クリア回数

関数「ClearRoundImage()」のサブルーチンです!
「byte 」は、「BYTE型」に対する処理用です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-12)関数「void clear_round_short_h(
short *p,int h,int v,int inc,int data);」

    void    clear_round_short_h(                    // 周囲クリア:short:上下辺
                short   *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data );                     // データ

関数「ClearRoundImage()」のサブルーチンです!
「short_h」は、「short型」で水平線≪具体的には画像の
最上辺・最下辺≫処理用です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-13)関数「void clear_round_short_v(
short *p,int h,int v,int inc,int data);」

    void    clear_round_short_v(                    // 周囲クリア:short:左右辺
                short   *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data );                     // データ

関数「ClearRoundImage()」のサブルーチンです!
「short_v」は、「short型」で垂直線≪具体的には画像の
最右辺・最左辺≫処理用です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-14)関数「void clear_round_short(
short *p,int h,int v,int inc,int data,
int n1,int n2);」

    void    clear_round_short(                      // 周囲クリア:short
                short   *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data,                       // データ
                int     n1,                         // 水平線クリア回数
                int     n2 );                       // 垂直線クリア回数

関数「ClearRoundImage()」のサブルーチンです!
「BYTE 」は、「BYTE型」に対する処理用です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-15)関数「void clear_round_long_h(
long *p,int h,int v,int inc,int data);」

    void    clear_round_long_h(                     // 周囲クリア:long:上下辺
                long    *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data );                     // データ

関数「ClearRoundImage()」のサブルーチンです!
「long _h」は、「long型」で水平線≪具体的には画像の
最上辺・最下辺≫処理用です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-16)関数「void clear_round_long_v(
long *p,int h,int v,int inc,int data);」

    void    clear_round_long_v(                     // 周囲クリア:long:左右辺
                long    *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data );                     // データ

関数「ClearRoundImage()」のサブルーチンです!
「long_v」は、「long型」で垂直線≪具体的には画像の
最右辺・最左辺≫処理用です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-17)関数「void clear_round_long(
long *p,int h,int v,int inc,int data,
int n1,int n2);」

    void    clear_round_long(                       // 周囲クリア:long
                long    *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                int     data,                       // データ
                int     n1,                         // 水平線クリア回数
                int     n2 );                       // 垂直線クリア回数

関数「ClearRoundImage()」のサブルーチンです!
「long 」は、「long型」に対する処理用です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-18)関数「void clear_round_float(
float*p,int h,int v,int inc,double data,int n1,int n2);」

    void    clear_round_float(                      // 周囲クリア:float
                float   *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                double  data,                       // データ
                int     n1,                         // 水平線クリア回数
                int     n2 );                       // 垂直線クリア回数

関数「ClearRoundImage()」のサブルーチンです!
「float」は、「float型」に対する処理用です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-19)関数「void clear_round_double_h(
double *p,int h,int v,int inc,double data);」

    void    clear_round_double_h(                   // 周囲クリア:double:上下辺
                double  *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                double  data );                     // データ

関数「ClearRoundImage()」のサブルーチンです!
「double_h」は、「double 型」で水平線≪具体的には
画像の最上辺・最下辺≫処理用です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-20)関数「void clear_round_double_v(
double *p,int h,int v,int inc,double data);」

    void    clear_round_double_v(                   // 周囲クリア:double:左右辺
                double  *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                double  data );                     // データ

関数「ClearRoundImage()」のサブルーチンです!
「double_v」は、「double 型」で垂直線≪具体的には
画像の最右上辺・最左辺≫処理用です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-21)関数「void clear_round_double(
double *p,int h,int v,int inc,double data,
int n1,int n2);」

    void    clear_round_double(                     // 周囲クリア:double
                double  *p,                         // 画像の左上
                int     h,                          // 水平幅
                int     v,                          // 垂直幅
                int     inc,                        // 増加幅
                double  data,                       // データ
                int     n1,                         // 水平線クリア回数
                int     n2 );                       // 垂直線クリア回数

関数「ClearRoundImage()」のサブルーチンです!
「double 」は、「double 型」に対する処理用です!
★詳細★は、後で説明:【ファイル「CopyClear010.cpp」が
対象】します!

(4-12-22)関数「void copy_byte_short(
TypeArray* ps,TypeArray* pd);」

    void    copy_byte_short(                        // 転送:BYTE→short
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

関数「Copy()」のサブルーチンです!
「byte_short」は、「BYTE型」画素画像から
「short型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-23)関数「void copy_byte_int(
TypeArray* ps,TypeArray* pd);」

    void    copy_byte_int(                          // 転送:BYTE→int
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

関数「Copy()」のサブルーチンです!
「byte_int」は、「BYTE型」画素画像から
「int型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-24)関数「void copy_byte_float(
TypeArray* ps,TypeArray* pd);」

    void    copy_byte_float(                        // 転送:BYTE→float
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

関数「Copy()」のサブルーチンです!
「byte_float」は、「BYTE型」画素画像から
「float型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-25)関数「void copy_byte_double(
TypeArray* ps,TypeArray* pd);」

    void    copy_byte_double(                       // 転送:BYTE→double
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

関数「Copy()」のサブルーチンです!
「byte_double」は、「BYTE型」画素画像から
「double型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-26)関数「void copy_short_byte(
TypeArray* ps,TypeArray* pd);」

    void    copy_short_byte(                        // 転送:short→BYTE
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

関数「Copy()」のサブルーチンです!
「short_byte 」は、「short型」画素画像から
「BYTE型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-27)関数「void copy_short_int(
TypeArray* ps,TypeArray* pd);」

    void    copy_short_int(                         // 転送:shortint
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

関数「Copy()」のサブルーチンです!
「short_int 」は、「short型」画素画像から
「int型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-28)関数「void copy_short_float(
TypeArray* ps,TypeArray* pd);」

    void    copy_short_float(                       // 転送:shortfloat
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

関数「Copy()」のサブルーチンです!
「short_float」は、「short型」画素画像から
「float型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-29)関数「void copy_short_double(
TypeArray* ps,TypeArray* pd);」

    void    copy_short_double(                      // 転送:shortdouble
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

関数「Copy()」のサブルーチンです!
「short_double」は、「short型」画素画像から
「double型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-30)関数「void copy_int_byte(
TypeArray* ps,TypeArray* pd);」

    void    copy_int_byte(                          // 転送:int→BYTE
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

関数「Copy()」のサブルーチンです!
「int_byte」は、「int型」画素画像から
「BYTE型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-31)関数「void copy_int_short(
TypeArray* ps,TypeArray* pd);」

    void    copy_int_short(                         // 転送:intshort
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

関数「Copy()」のサブルーチンです!
「int_short」は、「int型」画素画像から
「short型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-32)関数「void copy_int_float(
TypeArray* ps,TypeArray* pd);」

    void    copy_int_float(                         // 転送:intfloat
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

関数「Copy()」のサブルーチンです!
「int_float」は、「int型」画素画像から
「float型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-33)関数「void copy_int_double(
TypeArray* ps,TypeArray* pd);」

    void    copy_int_double(                        // 転送:intdouble
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

関数「Copy()」のサブルーチンです!
「int_double」は、「int型」画素画像から
「double型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-34)関数「void copy_float_byte(
TypeArray* ps,TypeArray* pd);」

    void    copy_float_byte(                        // 転送:float→BYTE
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

「float_BYTE 」は、「float型」画素画像から
「BYTE型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-35)関数「void copy_float_short(
TypeArray* ps,TypeArray* pd);」

    void    copy_float_short(                       // 転送:floatshort
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

「float_short」は、「float型」画素画像から
「short型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-36)関数「void copy_float_int(
TypeArray* ps,TypeArray* pd);」

    void    copy_float_int(                         // 転送:floatint
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

「float_int」は、「float型」画素画像から
「int型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-37)関数「void copy_float_double(
TypeArray* ps,TypeArray* pd);」

    void    copy_float_double(                      // 転送:floatdouble
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

「float_double」は、「float型」画素画像から
「double型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-38)関数「void copy_double_byte(
TypeArray* ps,TypeArray* pd);」

    void    copy_double_byte(                       // 転送:double→BYTE
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

「double_BYTE」は、「double型」画素画像から
「BYTE型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-44)関数「void copy_double_short(
TypeArray* ps,TypeArray* pd);」

    void    copy_double_short(                      // 転送:doubleshort
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

「double_short」は、「double型」画素画像から
「short型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-40)関数「void copy_double_int(
TypeArray* ps,TypeArray* pd);」

    void    copy_double_int(                        // 転送:doubleint
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

「double_int」は、「double型」画素画像から
「int型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

(4-12-41)関数「void copy_double_float(
TypeArray* ps,TypeArray* pd);」

    void    copy_double_float(                      // 転送:doublefloat
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

「double_float」は、「double型」画素画像から
「float型」画素画像へのコピー(転送)です!
★詳細★は、後で説明:【ファイル「CopyClear020.cpp」が
対象】します!

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

3月4日分迄の講義とします!本日の講義はココまでと
します!作者の私でも疲れたのだから、新しい概念に接して居る受講生の皆様もお疲れと思います!
オマケにNoteサーバーが、人気に成ったのか想定外に
重たく、追加編集が遣り難く成り追加する事が出来ません!多くサブルーチン紹介が残って居ますが、別の文書に続けます!

文末

続きは、「解説クラスCopyClear(9)」に成り
ます!
「(9)」では、サブルーチンとして作成した続きの紹介で
す!引き続き御贔屓して受講して下さい!

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