見出し画像

解説クラスCopyClear(1)

解説クラスCopyClear(1)


2024年2月23初講(初稿)

本格的に画像を処理するソースコードを記述した
クラス「classCopyClear」の解説を行います!
何故、タイトルが「解説クラスCopyClear(1)」
と「(1)」が付いて居るかと言うと大きいクラスだから
です!
ソースコードでヘッダーファイル「CopyClear.h」と
定義分とその実体を記述した「○○.cpp」ファイルが、
「CopyClear.cpp」・「CopyClear000.cpp」・
「CopyClear010.cpp」・「CopyClear020.cpp」・
「CopyClear030.cpp」・「CopyClear040.cpp」・
「CopyClear100.cpp」・「CopyClear100.cpp」・
「CopyClear110.cpp」・「CopyClear120.cpp」・
「CopyClear130.cpp」・「CopyClear200.cpp」・
「CopyClear300.cpp」・「CopyClear310.cpp」・
「CopyClear320.cpp」・「CopyClear330.cpp」・
「CopyClear340.cpp」・「CopyClear350.cpp」・
「CopyClear400.cpp」・「CopyClear410.cpp」・
「CopyClear420.cpp」・「CopyClear430.cpp」・
「CopyClear440.cpp」と多数有ります!因みに
「CopyClear000.cpp」・「CopyClear100.cpp」・
「CopyClear200.cpp」・「CopyClear300.cpp」・
「CopyClear400.cpp」と大まかに分類した同種、
「CopyClear000.cpp」⇒引数チェック用の関数群と
基本画像操作としての「CopyClear010.cpp」⇒
画像のクリアを行います、
「CopyClear020.cpp」⇒画像間のコピーを行います、
「CopyClear030.cpp」⇒画像のLUT変換等の画素値の
変換系を行います、
「CopyClear040.cpp」⇒LUTパターン作成と上記の
補助関数群、と「CopyClear0X0.cpp」系のファイルは、
基本の基本と言って良い処理の記述です!
「CopyClear100.cpp」⇒データソート(画像で無く
一次元データが対象)で内訳
「CopyClear1100.cpp」⇒マルチソート≪上記の関連関数群

「CopyClear120.cpp」⇒キー付きソート≪上記の関連関数群

「CopyClear130.cpp」⇒データソート関連部≪上記の
関連関数群≫と「CopyClear1X0.cpp」系のファイルは、
データソート用と言って良い!
「CopyClear200.cpp」⇒パターン画像の作成
「CopyClear300.cpp」⇒画像の幾何変換(拡大・縮小)
関数群、内訳は、
「CopyClear310.cpp」⇒画像の幾何変換(鏡像)関数群
「CopyClear320.cpp」⇒画像の幾何変換(回転)関数群
「CopyClear330.cpp」⇒画像の幾何変換(回転続き)
関数群
「CopyClear340.cpp」⇒画像の幾何変換(回転の続きの
続き)関数群
「CopyClear350.cpp」⇒画像の幾何変換(平行移動)
関数群と「CopyClear3X0.cpp」系のファイルは、
画像の幾何変換用と言って良い!
「CopyClear400.cpp」⇒正規相関≪画像の比較用≫関数群
「CopyClear410.cpp」⇒正規相関(基本部)関数群
「CopyClear420.cpp」⇒正規相関(大規模画像用)関数群
「CopyClear430.cpp」⇒正規相関(4×4画素・
4×M画素用と限定サイズに特化した高速版)関数群
「CopyClear440.cpp」⇒正規相関(n×mマスク付き)
関数群と「CopyClear4X0.cpp」系のファイルは、
正規相関≪最後に追加して居るのは、私が20世紀の
画像処理技術で最後に接した重要な手法なので基本:詰り、
良く使われる場所の最後に追加したソースコードで
★画像の比較とかに使用される画像認識・画像特定の
基本部で同じ物体の追跡等にも使える重要な手法です!
更に元々は、特殊なボード【エッセイ『20世紀最後の
お仕事』
に発表したエッセイで紹介して有る富士通が開発
したボードに使用されている方法をCPUだけで出来る様に
改造した物が入って居ます!】★≫と恐らく、
色々な応用に使用出来る物≪推測ですがAI技術で画像比較
に使用される基本アルゴリズム≫ですと紹介して置きます!

1.ヘッダーファイル

比較的、小サイズのヘッダーファイルなので全て
noteの「code」機能で以下の様に示した後で解説して
行きます!と記載して「code」機能をシヨウしたら大き過ぎ
たのかnoteエディタが編集が変≪編集作業が重たく動作
シズライ≫に成ったので

ダウンロードファイルを用意しましたのでご自身でダウンロードして参考にして下さい!
尚、「タブストップとコメント」等がご自身が使用されて
いるテキストエディタで不都合な場合が在りますから、
ダウンロードする前に
解説『ソースコード書式』を読んで確認してからダウン
ロードして下さい!勿論、ここでダウンロードするで無く、
解説『投げ銭方式ライブラリのダウンロード』でライブラリ
全体をダウンロード出来ますのでダウンロードしたら、その
ダウンロードしたソースコードを参照して下さい!

(1)「#include」等、「#」構文を使用した先頭部分

#if !defined(AFX_COPYCLEAR_H__56288A65_A047_4DC5_B7D2_475474DF0802__INCLUDED_)
#define AFX_COPYCLEAR_H__56288A65_A047_4DC5_B7D2_475474DF0802__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include    "Support.h"                             // サポート関数定義部

「#if!defined(AFX_COPYCLEAR_H__・・・」は、
WindowsXP上でVS(ヴィジュアルスタジオ、以下
「()」内は省略しVSと表記)が自動生成した、
「#include」を多重に動作させて無駄に定義をコンパイラ
システムに読み込ませ無い工夫としての
「#if!defined()・・・#endif」構文です!

#if_MSC_VER>1000
#pragma once
#endif//_MSC_VER>1000
と3行もVSが自動生成したものでVSに取っての都合と
思って居るから、Windows以外のシステムを
お使いの人は、無くても良い物と思います!!

#include"Support.h"//サポート関数定義部

この「Support.h」で「#define」定義した数値定数、及び、
この単純な型名の定義が記述された定義ファイルを
インクルードする事を等や
画像自体を記述した「TypeArray.h」等、
この画像処理ライブラリで必要な定義がインクルードされ
ます!

(2)クラス定義

class CopyClear : public Support                    // クラス定義
{
private:

から途中を所略し

/********************************************************************************************/
/*****  内部で使用するデータ                                                            *****/
/********************************************************************************************/

protected:

    int     m_swDegreeRadian;                       // 0:ディグリー/ 1:ラジアン

};

中身に関してはコレから解説!

(3)クラス内ローカル構造体定義

private:
    struct          TypeSort {                      // ソート用データ構造
        short       key;                            // ソートキー部
        short       ix;                             // ソートインデックス部
    };                                              // 型名「TypeSort」

「private:」は、プライベートとクラス内のみで
使用&アクセス出来る構造体にして
構造体名「TypeSort」で構造体のメンバーでソート用の
構造体を示します!
変数「short key;」は、ソートデータの「キー」部を意味
します!
変数「short ix;」は、ソートデータの「インデックス」部
と他のデータへのインデックスを示します!
★注意★変数「short ix;」と実際に必要なデータを
インデックスで示して居ます!
私が「ポインタ推し」なのに何故、と訝しく思う人に
説明します!
コンパクト≪ポインタならば、4バイト:32ビット必要
だからです!≫にしたい為です!
キーとソートデータ用のキーデータが「short型」と
2バイトなので合わせて4バイトと収まり易いサイズだか
らです!
因みに4バイトのポインタにするとバウンダリ境界が
8バイト単位に多くのシステムで成るのでメモリが大量に
成り、処理が遅く成るから避ける為にインデックスにしま
した!

(4)クラス「CopyClear構文で定義」した!メソッド(メンバー関数)の定義概要

(4-1)コンストラクタ/デストラクタ

public:
    CopyClear();                                    // コンストラクタ
    virtual ~CopyClear();                           // デストラクタ

「public:」は、パブリック属性とアクセス可能にして居
ます!上記の様にクラス定義のお馴染みの記載です!

(4-2)関数「Clear()」

英単語「Clear」で「きれいになる、片付{かたづ}く」の
意味だが、この画像処理ライブラリの関数では、
画像一枚をクリア=同じ値で埋める⇒典型的には
「0クリア」と画素の値=0で埋めつくす!

public:                                             // 画像関数として正規に見せるもの
                                                    // 画像クリア/画像コピー
    int     Clear(                                  // クリア:汎用
                TypeArray*  pa,                     //  配列
                int         data );                 //  データ
    int     Clear(                                  // クリア:実数
                TypeArray*  pa,                     //  配列
                double      data );                 //  データ

(4-2-1)関数「Clear(TypeArray* pa,int data)」

    int     Clear(                                  // クリア:汎用
                TypeArray*  pa,                     //  配列
                int         data );                 //  データ

と画像「TypeArray* pa」とクラスTypeArrayへの
ポインタを★注意★これから、画像と呼ばせて
いただきます!
に対して仮引数「int data」と書き込む整数値データを
意味します!

(4-2-2)関数「Clear(TypeArray* pa,double data)」

    int     Clear(                                  // クリア:実数
                TypeArray*  pa,                     //  配列
                double      data );                 //  データ

と画像「TypeArray* pa」とクラスTypeArrayへの
ポインタを★注意★これから、画像と呼ばせて
いただきます!
に対して仮引数「double data」と書き込む
実数(倍精度浮動小数点数)値データを意味します!
★注意★勿論、関数名が同じで書き込む数値型が
「int data」・「double data」と多重定義の関数に
して居ます!

(4-3)関数「Copy()」系

    int     Copy(                                   // 転送
                TypeArray*  ps,                     // S配列
                TypeArray*  pd );                   // D配列

このクラス「classCopyClear{}」先ほど説明した
関数「Clear()」と、これから、説明する関数「Copy()」を
典型的な画像処理なのでクラス名にして居ます!
★注意★何故、典型的かと説明しよう?!
関数「Clear()」は、画像「TypeArray* 型」引数が、
1個の画像を主役と見た場合に「一項演算」を画像に施し
た事に相当し、関数「Copy()」は、
「Copy(TypeArray* ps,TypeArray* pd);」と
画像「TypeArray* ps」をソース(元画像)、
画像「TypeArray* pd」をディステェネーション(送り先、
或いは結果画像)に「元(S)⇒結果(D)」と引数が、
2個の画像を主役と見た場合に「二項演算」を画像に施し
た事に相当すると考えて下さい
★備考★「s」は、英単語「source」ソースで元とかの
意味です!
「d」は「destination」行き先(宛先)です。
詰り「sourcetodestination」とデータの向きを示します!
※注意※画像処理の多くは、この「二項演算」を画像に
施す事です!!

(4-3-1)関数「Copy()」

    int     Copy(                                   // 転送
                TypeArray*  ps,                     // S配列
                TypeArray*  pd );                   // D配列

仮引数「TypeArray* ps,」は、元(S)画像を示す
ポインタです!
仮引数「TypeArray* pd」は、結果(D)画像を示す
ポインタです!
この関数「Copy()」は、「S⇒D」と画像をコピーする
事を示します!
画像のサイズ≪水平幅(h)・垂直幅(v)≫が同じなら
ば、勿論、全画像コピーでサイズが異なれば、サイズを
小さいほうに合わせたサイズだけ処理します!
画素サイズ≪w(1/2/4と整数画素、及び、
101:単精度浮動小数点数値、102:倍精度浮動小数点数値)
≫が異なれば、後で説明する本体の方法でコピーします!

(4-3-2)関数「CopyUnsignedShortInt ()」

    int     CopyUnsignedShortInt(                   // 転送:UWORD→int
                TypeArray   *ps,                    // S配列
                TypeArray   *pd );                  // D配列

仮引数「TypeArray* ps,」は、元(S)画像を示す
ポインタです!
仮引数「TypeArray* pd」は、結果(D)画像を示す
ポインタです!
この、やたらと長い名前は、元(S)画像が
「unsigned short型」画素単位!
結果(D)画像が「int型」で有る場合の専用の関数を
示します!

(4-3-3)関数「CopyFieldFrame()」

    int     CopyFieldFrame(                         // フィールド→フレーム画像転送
                TypeArray*  ps,                     // S配列
                TypeArray*  pd );                   // D配列

仮引数「TypeArray* ps,」は、元(S)画像を示す
ポインタです!
仮引数「TypeArray* pd」は、結果(D)画像を示す
ポインタです!
両方とも画素単位は、「w=1」と1バイト単位画素専用
です!
★注意★ここで「Field」・「Frame」は、元々ADS社の
画像処理装置はアナログの映像信号からデジタル信号とし
て量子化して画像メモリにキャプチャーする装置ですが、
アナログビデオカメラ≒アナログTV放送の用語を
フンダンニ使用しています「Frame」は、ビデオフレーム
≪1秒間に30枚の画像、詰り、1/30秒≒
33ms(ミリセカンド)で1枚の画像としてデジタル的に
は、VGA(640【横:水平方向】×480【縦:垂直
方向】)画像がキャプチャー≫出来ますのでフレーム
「Frame」と呼んで居ました「Frame」=枠(一枚の画像の
枠との意味)!
が、更にこれが、時間的に2枚≪インターレス方式と言う
言葉を聴いた事が有ると思いますが、
現在のデジタルカメラでも撮影方式の説明用語に記されて
いる物でアナログTV放送時代に1/30秒の間隔で
映像コマが送られて来るのでは、カクカクと荒く感じると
の事で色々検討(大昔のアナログ放送は工夫の塊だったの
です)した結果1/60秒≒17ms間隔でコマ送り
出来る様にした工夫がインターレス方式で、
この時はフレーム「Frame」で無くフィールド「Field」=
VGAの縦:垂直方向偶奇行毎に分けて偶数番目の画像
フィールド「Field」と奇数番目の画像フィールド
「Field」に分けて偶奇合わせるとフレーム「Frame」画像
に成る≫事は、理解して下さい!
そしてADS社の画像処理装置は、フレームでも
フィールドでも何方でもキャプチャー出来る機能が有り
ました!
その関係でこの関数は、フィールド
≪640【横:水平方向】×240【縦:垂直方向】と
VGAを縦に偶奇半分≫をフレームサイズに変更する関数
です!
如何、行って居るかは関数本体の説明で行います!

(4-3-4)関数「RepairImage()」

    int     RepairImage(                            // 欠陥画素修復                         
                TypeArray*  pa,                     //  配列
                int         tbl[],                  //  欠陥場所テーブル
                int         n,                      //  欠陥個数
                int         mode=0 );               //  修復モード

欠陥画素修復と特殊用途です★

仮引数「TypeArray* pa,」は、画像を示すポインタです!
★注意★一般的な物では在りません?!
特殊用途・特定の機器の為に作成した事を
本体の「CopyClear020.cpp」を確認して判りました?!
参考までに新日鉄大分製鉄所に納品した撮像装置として
ラインセンサを使用したラインセンサの欠陥画素の補修用に
作成した特殊用途でした!!
本体の「CopyClear020.cpp」の説明で解説しますが、
特殊なカメラを使用した場合の処置の方法で参考程度に解説
は考えて居ます!

(4-4)LUT変換等各種画素値変換

    int     Convert(                                // LUT変換
                TypeArray*  ps,                     // S配列
                TypeArray*  pd,                     // D配列
                TypeArray*  lut                     // LUT配列
            );
    int     ConvertByte(                            // LUT変換,LUT=BYTE
                TypeArray*  ps,                     // S配列
                TypeArray*  pd,                     // D配列
                BYTE        *lut                    // LUTポインタ
            );
    int     ConvertWord(                            // LUT変換,LUT=short
                TypeArray*  ps,                     // S配列
                TypeArray*  pd,                     // D配列
                short       *lut                    // LUTポインタ
            );
    int     ConvertLine(                            // 水平/垂直方向輝度変換
                TypeArray*  ps,                     //  S配列
                TypeArray*  pd,                     //  D配列
                BYTE        tbl[],                  //  割合テーブル「1..255」
                int         mode                    //  0→水平方向,1→垂直方向
            );
    int     ConvertLine(                            // 水平/垂直方向輝度変換
                TypeArray*  ps,                     //  S配列
                TypeArray*  pd,                     //  D配列
                UWORD       tbl[],                  //  割合テーブル「1..1023」
                int         mode                    //  0→水平方向,1→垂直方向
            );
    int     Binarization(                           // 2値化
                TypeArray*  ps,                     // S配列(画像)
                TypeArray*  pd,                     // D配列
                int         t,                      // しきい値 0..255
                int         data = 255,             // 出力値:高位
                int         low = 0                 // 出力値:低位
            );
    int     BinarizationMyself(                     // 自身2値化:BYTE
                TypeArray   *p,                     // 配列(画像)情報
                int         data                    // 出力値:≠0時
            );
    int     BinarizationNonZeo(                     // 2値化:BYTE
                TypeArray   *ps,                    // S配列(画像)
                TypeArray   *pd,                    // D配列
                int         data                    // 出力値:≠0時
            );
    void    BinarizationXY(                         // 2値化:部分指定
                TypeArray*  ps,                     // S配列(画像)
                TypeArray*  pd,                     // D配列
                int         x,                      // X座標
                int         y,                      // Y座標
                int         h,                      // 水平幅
                int         v,                      // 垂直幅
                int         t,                      // しきい値 0..255
                int         data = 255,             // 出力値:高位
                int         low = 0                 // 出力値:低位
            );
    int     ConvertRgbToMono(                       // カラーから輝度への変換
                TypeArray*  pr,                     // S配列:赤
                TypeArray*  pg,                     // S配列:緑
                TypeArray*  pb,                     // S配列:青
                TypeArray*  pd );                   // D配列
    int     ConvertRgbToDiff(                       // カラーから輝度への変換
                TypeArray*  pr,                     // S配列:赤
                TypeArray*  pg,                     // S配列:緑
                TypeArray*  pb,                     // S配列:青
                TypeArray*  pY,                     // D配列:輝度
                TypeArray*  pRY,                    // D配列:R-Y
                TypeArray*  pBY );                  // D配列:B-Y
    int     ConvertDiffToRgb(                       // カラーから輝度への変換
                TypeArray*  pY,                     // S配列:輝度
                TypeArray*  pRY,                    // S配列:R-Y
                TypeArray*  pBY,                    // S配列:B-Y
                TypeArray*  pr,                     // D配列:赤
                TypeArray*  pg,                     // D配列:緑
                TypeArray*  pb );                   // D配列:青
    int     ConvertBmpToMono(                       // BMP(BGR)から輝度への変換
                TypeArray*  pbgr,                   // S配列:青緑赤
                TypeArray*  pd,                     // D配列
                int         rev=TRUE );             // 真→上下反転、偽→そのまま
    int     ConvertBmpToSingle(                     // BMP(BGR)から(単独の赤,緑,青)への変換
                TypeArray*  pbgr,                   // S配列:青緑赤
                TypeArray*  pd,                     // D配列:単独の赤,緑,青
                int         sel,                    // 0:赤,1:緑,2:青
                int         rev=TRUE );             // 真→上下反転、偽→そのまま
    int     CalculateRgbToMono(                     // カラー変換(RGB→輝度)算出
                int         r,                      //  赤
                int         g,                      //  緑
                int         b );                    //  青
    void    CalculateRgbToDiff(                     // カラー変換(RGB→色差)算出
                int         r,                      //  赤
                int         g,                      //  緑
                int         b,                      //  青
                int&        Y,                      //  結果:輝度
                int&        RY,                     //  結果:R-Y
                int&        BY );                   //  結果:B-Y
    void    CalculateDiffToRgb(                     // カラー変換(RGB→色差)算出
                int         Y,                      //  輝度
                int         RY,                     //  R-Y
                int         BY,                     //  B-Y
                int&        r,                      //  結果:赤
                int&        g,                      //  結果:緑
                int&        b );                    //  結果:青

    int     EraseMinusImage(                        // 負画像除去
                TypeArray   *img );                 //  画像

LUT≪LookupTable≫とは、
読み「ルックアップテーブル」で概要的説明「計算機科学に
おけるルックアップテーブル(英:Lookuptable)とは、
複雑な計算処理を単純な配列の参照処理で置き換えて
効率化を図るために作られた、配列や連想配列」と有り
ますが、この画像処理ライブラリでは、
元画像(S)⇒LUT変換⇒結果(D)画像と演算を行う
処理です!
ココでは、関連して2値化や、カラー(RGB3原色)画像
からモノクロ画像、及び、カラー(RGB3原色)と
カラー(色差式)との変換・逆変換等を扱います!

(4-4-1)関数「int Convert(
TypeArray* ps,TypeArray* pd,TypeArray* lut);」

    int     Convert(                                // LUT変換
                TypeArray*  ps,                     // S配列
                TypeArray*  pd,                     // D配列
                TypeArray*  lut                     // LUT配列
            );

仮引数「TypeArray* ps,」は、元画像(S)
仮引数「TypeArray* pd,」は、結果画像(D)
仮引数「TypeArray* lut」は、LUTを示す
「一次元配列」です!
勿論、「S・D」は、関数「Copy()」で説明した様に
S画像⇒処理⇒D画像への格納を意味します!
ところでLUTも「TypeArray* 」にして居るのは、
画像情報「adr,h,v,inc,w」の内、水平幅「v=1」と
一次元と見なして単純な一次元配列的に指定できる様にして
居ます!
★注意★画素単位「w」で色々な型「BYTE型・short型・
int型・float型・double 型」が使用出来る☆
備考☆元々、ADS社の画像処理装置にC言語でコマンド
言語「PIPL」と名付けたインタプリタを作成した時に
便利だったからで!其れを踏襲していて、
後にC++で多重定義が使用出来る事が判ってLUTを
独立したデータタイプで定義すれば良かったと後で思うの
だ?!
因みに「PIPL」のマニュアルは
解説『参考:ADS社画像処理装置』から、PDF形式の
ファイルをダウンロード出来る様にしています!
そしてコノ関数「int Convert(
TypeArray* ps,TypeArray* pd,TypeArray* lut);」で
画像のLUT変換全てを行えますが、直接、LUT配列を
記載して無いので内部で個別に直接駆動関数に分岐します!

(4-4-2)関数「int ConvertByte(
TypeArray* ps,TypeArray* pd,BYTE *lut);」

    int     ConvertByte(                            // LUT変換,LUT=BYTE
                TypeArray*  ps,                     // S配列
                TypeArray*  pd,                     // D配列
                BYTE        *lut                    // LUTポインタ
            );

仮引数「TypeArray* ps,」は、元画像(S)
仮引数「TypeArray* pd,」は、結果画像(D)
仮引数「BYTE *lut」は、LUTを直接示す
「BYTE型=unsigned char型」と1バイト符号無し画素単位の
「一次元配列」です!
このLUTで元画像(S)の個別画素S[x,y]・
結果画像(D)の個別画素D[x,y]と考えて数式
D[x,y]←LUT[S[x,y]]:(x全域)(y全域)で
現わせるような処理を行うのがLUT変換です!

(4-4-3)関数「int ConvertWord(
TypeArray* ps,TypeArray* pd,short *lut);」

    int     ConvertWord(                            // LUT変換,LUT=short
                TypeArray*  ps,                     // S配列
                TypeArray*  pd,                     // D配列
                short       *lut                    // LUTポインタ
            );

仮引数「TypeArray* ps,」は、元画像(S)
仮引数「TypeArray* pd,」は、結果画像(D)
仮引数「short *lut」は、LUTを直接示す「short型」と
2バイト符号有り画素単位の「一次元配列」です!
このLUTで元画像(S)の個別画素S[x,y]・
結果画像(D)の個別画素D[x,y]と考えて数式
D[x,y]←LUT[S[x,y]]:(x全域)(y全域)
で現わせるような処理を行うのがLUT変換です!

(4-4-4)関数「int ConvertLine(
TypeArray* ps,TypeArray* pd,BYTE tbl[],int mode);」

    int     ConvertLine(                            // 水平/垂直方向輝度変換
                TypeArray*  ps,                     //  S配列
                TypeArray*  pd,                     //  D配列
                BYTE        tbl[],                  //  割合テーブル「1..255」
                int         mode                    //  0→水平方向,1→垂直方向
            );

仮引数「TypeArray* ps,」は、元画像(S)
仮引数「TypeArray* pd,」は、結果画像(D)
仮引数「BYTE *lut」は、LUTを示す
「BYTE型=unsigned char型」と1バイト符号無し画素単位
の「一次元配列」です!
★注意★ここで「Line」名称は、「一次元配列」の意味では
ありません?!
特殊用途で「Lineライン=線分(縦方向・横方向)」の
意味で実体の解説で詳細は説明:
【ファイル「CopyClear030.cpp」が対象】します!

(4-4-5)関数「int ConvertLine(
TypeArray* ps,TypeArray* pd,UWORDtbl[],int mode);」

    int     ConvertLine(                            // 水平/垂直方向輝度変換
                TypeArray*  ps,                     //  S配列
                TypeArray*  pd,                     //  D配列
                UWORD       tbl[],                  //  割合テーブル「1..1023」
                int         mode                    //  0→水平方向,1→垂直方向
            );

仮引数「TypeArray* ps,」は、元画像(S)
仮引数「TypeArray* pd,」は、結果画像(D)
仮引数「UWORD*lut」は、LUTを示す
「UWORD型=unsigned short型」2バイト符号無し画素単位
の「一次元配列」です!
★注意★ここで「Line」名称は、「一次元配列」の意味では
ありません?!
特殊用途で「Lineライン=線分(縦方向・横方向)」の意味
で実体の解説で詳細は説明:
【ファイル「CopyClear030.cpp」が対象】します!

(4-4-6)関数「int Binarization(
TypeArray* ps,TypeArray* pd,int t,int data=255,
int low=0);」

    int     Binarization(                           // 2値化
                TypeArray*  ps,                     // S配列(画像)
                TypeArray*  pd,                     // D配列
                int         t,                      // しきい値 0..255
                int         data = 255,             // 出力値:高位
                int         low = 0                 // 出力値:低位
            );

関数名「Binarization」は、英単語「binary」で
「二値」の意味で
「2(二)値化」する事を意味します!
★注意★画像処理で2値化とは、多値(1バイト=
8ビット画素では、0~255の画素値)とカメラ等で撮影
した自然画像から、2値(0・1とか後の算術処理で使い
易い形にするとか、0(黒)・255(高輝度白)と表示用
に使用)する、良く使われる処理です!
仮引数「TypeArray* ps,」は、元画像(S)
仮引数「TypeArray* pd,」は、結果画像(D)
仮引数「int t,」は、英単語「thresholdスレッショルド」の
頭文字で「しきい値=閾値」詰り≪境目に成る数値を示し
ます≫
仮引数「int data=255,」は、2値に変換結果(高い方の値
で省略時は、255と表示用:高輝度数値にして居ます!)
を示します!
仮引数「int low=0」は、2値に変換結果(低い方の値で
省略時は、0と表示用:黒にして居ます!)を示します!
★注意★詳細は、後で説明:
【ファイル「CopyClear030.cpp」が対象】します!

(4-4-7)関数「int BinarizationMyself(
TypeArray* p,int data=255);」

    int     BinarizationMyself(                     // 自身2値化:BYTE
                TypeArray   *p,                     // 配列(画像)情報
                int         data                    // 出力値:≠0時
            );

関数名「Binarization」は、英単語「binary」で「二値」の
意味で「Myself」は、自分自身を意味します!
そして画像は単項演算と1個だけ指定します!
「2(二)値化」する事を意味します!
★注意★画像処理で2値化とは、多値(1バイト=8ビット
画素では、0~255の画素値)とカメラ等で撮影した
自然画像から、2値(0・1とか後の算術処理で使い易い
形にするとか、0(黒)・255(高輝度白)と表示用に
使用)する良く使われる処理です!
使用頻度の多い「0」か、「0以外」を意味します!
仮引数「TypeArray* p,」は、1個だけ画像ポインタを指定
します!
これ自身を多値画像から2値画像への変換します!
仮引数「int data,」は、2値に変換結果を示します!
★注意★詳細は、後で説明:
【ファイル「CopyClear030.cpp」が対象】します!

(4-4-8)関数「int BinarizationNonZeo(
TypeArray* ps,TypeArray* pd,int data=255);」

    int     BinarizationNonZeo(                     // 2値化:BYTE
                TypeArray   *ps,                    // S配列(画像)
                TypeArray   *pd,                    // D配列
                int         data                    // 出力値:≠0時
            );

関数名「Binarization」は、英単語「binary」で
「二値」の意味で「2(二)値化」する事を意味します!
「NonZeo」は、「ゼロで無い」を意味します!
使用頻度の多い「0」か、「0以外」を意味します!
仮引数「TypeArray* ps,」は、元画像(S)
仮引数「TypeArray* pd,」は、結果画像(D)
仮引数「int data,」は、2値に変換結果を示します!
★注意★詳細は、後で説明:
【ファイル「CopyClear030.cpp」が対象】します!

(4-4-9)関数「void BinarizationXY(
TypeArray* ps,TypeArray* pd,int x,int y,int h,
int v,int t,int data=255,int low=0);

    void    BinarizationXY(                         // 2値化:部分指定
                TypeArray*  ps,                     // S配列(画像)
                TypeArray*  pd,                     // D配列
                int         x,                      // X座標
                int         y,                      // Y座標
                int         h,                      // 水平幅
                int         v,                      // 垂直幅
                int         t,                      // しきい値 0..255
                int         data = 255,             // 出力値:高位
                int         low = 0                 // 出力値:低位
            );

関数名「Binarization」は、英単語「binary」で「二値」の
意味で「2(二)値化」する事を意味します!
「XY」は、座標XYを示し、意味的には「座標指定・
サイズ指定で部分画像」を設定し、部分画像の範囲を処理!
仮引数「TypeArray* ps,」は、元画像(S)
仮引数「TypeArray* pd,」は、結果画像(D)
仮引数「int x,」は、X座標
仮引数「int y,」は、Y座標
仮引数「int h,」は、水平幅
仮引数「int v,」は、垂直幅と部分画像指定用です!
仮引数「int data=255」は、2値に変換結果(高い方の値で
省略時は、255と表示用:高輝度数値にして居ます!)を
示します!
★注意★詳細は、後で説明:
【ファイル「CopyClear030.cpp」が対象】します!

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

ここで「解説クラスCopyClear(1)」を終わり
ます!続きは、
解説クラスCopyClear(2)」に成ります
引き続き御贔屓して受講して下さい!

文末




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