using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace vcsFSratioNL
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        //---------------------------------------------------------------------------------

        private void Form1_Load(object sender, EventArgs e)
        {
            toolStripLabel1.Text = "バンド幅";
            toolStripTextBox1.Text = "0.4";
        }
        //---------------------------------------------------------------------------------

        private void toolStripButton1_Click(object sender, EventArgs e)
        {
            main_part();
            MessageBox.Show("処理完了", "完了通知");
        }
        //------------------------------------------------------------------------------
        private void main_part()
        {
            //フーリエスペクトル比算定
            //分子・分母にするデータのサンプリングピッチ・データ数は等しくとる
            int nnn, i;
            string fnameR="";
            string fnameW="";
            System.IO.StreamReader sr;
            System.IO.StreamWriter sw;
            string dat;
            string[] sbuf;
            char delim = ',';


            int ncase, icase, nn=0, nd;
            double dt=0.0, band;

            int ndmax = (int)(Math.Pow(2, 16));


            double[] fs01 = new double[ndmax + 1]; //分子原スペクトル
            double[] fs02 = new double[ndmax + 1]; //分子原スペクトル
            double[] fsp1 = new double[ndmax + 1]; //分子平滑化スペクトル
            double[] fsp2 = new double[ndmax + 1]; //分母平滑化スペクトル
            double[] fspr = new double[ndmax + 1]; //平滑化スペクトル比
            double[] fq = new double[ndmax + 1]; //振動数

            for (i = 0; i <= ndmax; i++)
            {
                fs01[i] = 0.0;
                fs02[i] = 0.0;
                fsp1[i] = 0.0;
                fsp2[i] = 0.0;
                fq[i] = 0.0;
            }

            //平滑化バンド幅設定
            band = double.Parse(toolStripTextBox1.Text);

            //入出力ファイル読み込み
            openFileDialog1.InitialDirectory = System.IO.Directory.GetCurrentDirectory();
            if (openFileDialog1.ShowDialog() == DialogResult.OK) { fnameR = openFileDialog1.FileName; }
            sr = new System.IO.StreamReader(fnameR, System.Text.Encoding.Default);
            dat = sr.ReadLine(); sbuf = dat.Split(delim); ncase = int.Parse(sbuf[0]);
            string[] strcom1 = new string[ncase];
            string[] strcom2 = new string[ncase];
            string[] rn1 = new string[ncase];
            string[] rn2 = new string[ncase];
            string[] wn0 = new string[ncase];
            string[] slog = new string[ncase];
            for (icase = 1; icase <= ncase; icase++)
            {
                dat = sr.ReadLine(); sbuf = dat.Split(delim);
                strcom1[icase - 1] = sbuf[0];
                strcom2[icase - 1] = sbuf[1];
                rn1[icase - 1] = sbuf[2];
                rn2[icase - 1] = sbuf[3];
                wn0[icase - 1] = sbuf[4];
                slog[icase - 1] = sbuf[5];
            }
            sr.Close();

            for (icase = 1; icase <= ncase; icase++)
            {
                for (nnn = 1; nnn <= 2; nnn++)
                {
                    //原波形読み込みと平滑化フーリエスペクトル計算
                    switch (nnn)
                    {
                        case 1:
                            fnameR = System.IO.Path.GetDirectoryName(fnameR) + "\\" + rn1[icase - 1];
                            CALFSP(fnameR, out dt, out nn, band, fs01, fsp1);
                            break;
                        case 2:
                            fnameR = System.IO.Path.GetDirectoryName(fnameR) + "\\" + rn2[icase - 1];
                            CALFSP(fnameR, out dt, out nn, band, fs02, fsp2);
                            break;
                    }
                }
                //スペクトル比計算
                nd = (int)(nn / 2);
                for (i = 0; i <= nd; i++)
                {
                    fspr[i] = fsp1[i] / fsp2[i];
                }
                //振動数設定
                for (i = 0; i <= nd; i++)
                {
                    fq[i] = (double)i / (double)nn / dt; //振動数
                }

                //結果書き出し
                fnameW = System.IO.Path.GetDirectoryName(fnameR) + "\\" + wn0[icase - 1] + ".csv";
                sw = new System.IO.StreamWriter(fnameW, false, System.Text.Encoding.Default);
                dat = "バンド幅" + "," + band.ToString(); sw.WriteLine(dat);
                dat = "データ数" + "," + (nd + 1).ToString(); sw.WriteLine(dat);
                dat = "振動数,分子原SP,分母原SP,平滑化分子SP,平滑化分母SP,平滑化SP比"; sw.WriteLine(dat);
                for (i = 0; i <= nd; i++)
                {
                    dat = fq[i].ToString("0.000");
                    dat = dat + "," + fs01[i].ToString("0.000");
                    dat = dat + "," + fs02[i].ToString("0.000");
                    dat = dat + "," + fsp1[i].ToString("0.000");
                    dat = dat + "," + fsp2[i].ToString("0.000");
                    dat = dat + "," + fspr[i].ToString("0.000");
                    sw.WriteLine(dat);
                }
                sw.Close();

                PLTCTL(icase, nn, dt, fq, fs01, fs02, fsp1, fsp2, fspr, wn0, strcom1, strcom2, slog, fnameR);
            }
        }
        //------------------------------------------------------------------------------

        private void CALFSP(string fnameR, out double dt, out int nn, double band, double[] fs0, double[] fsp)
        {
            System.IO.StreamReader sr;
            string dat;
            string[] sbuf;
            char delim = ',';
            int i,ndata, nd;
            double ddymax, dymax, ymax, df;

            //原波形読み込み
            sr = new System.IO.StreamReader(fnameR, System.Text.Encoding.Default);
            dat = sr.ReadLine(); sbuf = dat.Split(delim);
            dat = sr.ReadLine(); sbuf = dat.Split(delim); dt = double.Parse(sbuf[1]);
            dat = sr.ReadLine(); sbuf = dat.Split(delim); ndata = int.Parse(sbuf[1]);
            nn = 2;
            do
            {
                nn = nn * 2;
            } while (nn < ndata);
            nd = (int)(nn / 2);
            double[] ddy = new double[nn];
            double[] dy = new double[nn];
            double[] y = new double[nn];
            double[] xr = new double[nn];
            double[] xi = new double[nn];
            for (i = 1; i <= nn; i++)
            { //データ数を2の階乗にセット
                ddy[i - 1] = 0.0; dy[i - 1] = 0.0; y[i - 1] = 0.0;
            }
            for (i = 1; i <= ndata; i++)
            {
                dat = sr.ReadLine(); sbuf = dat.Split(delim); ddy[i - 1] = double.Parse(sbuf[0]);
            }
            sr.Close();

            //平滑化フーリエスペクトル作成
            IACC(ndata, dt, ddy, dy, y, out ddymax, out dymax, out ymax); //数値積分
            CRAC(ndata, dt, ddy, dy, y, ddymax, dymax, ymax); //基線補正
            for (i = 1; i <= nn; i++)
            {
                xr[i - 1] = ddy[i - 1];
                xi[i - 1] = 0.0;
            }
            FFT(nn, xr, xi); //フーリエ変換
            for (i = 1; i <= nn; i++)
            { //戻り値をデータ数で除す
                xr[i - 1] = xr[i - 1] / (double)nn;
                xi[i - 1] = xi[i - 1] / (double)nn;
            }
            for (i = 1; i <= nd + 1; i++)
            {
                fs0[i - 1] = dt * (double)nn * Math.Sqrt(xr[i - 1] * xr[i - 1] + xi[i - 1] * xi[i - 1]); //分子フーリエスペクトル
                fsp[i - 1] = fs0[i - 1];
            }
            df = 1.0 / dt / (double)nn;
            SWIN(nn, fsp, df, band); //スペクトル平滑化

        }
        //------------------------------------------------------------------------------

        private void PLTCTL(int icase, int nn, double dt, double[] fq, double[] fs01, double[] fs02,
                            double[] fsp1, double[] fsp2, double[] fspr, string[] wn0,
                            string[] strcom1, string[] strcom2, string[] slog, string fnameR)
        {
            //作図
            string fnameD="";
            int i,jj;
            int kpt;
            string sxjiku="";
            string syjiku="";
            int HSIZE = 1000;
            int DHL = 100;
            int DHR = 20;
            int VSIZE = 500;
            int DVL = 100;
            int DVU = 70;
            int kxi0, kxf0, kyi0, kyf0;
            double figxmin = 0.0, figxmax = 0.0, figdx = 0.0;
            double figymin = 0.0, figymax = 0.0, figdy = 0.0;
            int nd;
            double df, band=0.0, fsmax=0.0;
            string comR="";
            Graphics g;
            Bitmap bmp;

            nd = (int)(nn / 2);
            double[] datax = new double[nd + 1];
            double[] datay = new double[nd + 1];
            kxi0 = DHL; kxf0 = HSIZE - DHR;
            kyi0 = DVU; kyf0 = VSIZE - DVL;
            switch (slog[icase - 1])
            {
                case "N":
                    figxmin = 0.0; figxmax = 20.0; figdx = 1.0;
                    figymin = 0.0; figymax = 1.0; figdy = 0.1;
                    sxjiku = "振動数 (Hz)";
                    break;
                case "L":
                    figxmin = -2.0; figxmax = 1.0; figdx = 1.0;
                    figymin = -1.0; figymax = 3.0; figdy = 1.0;
                    sxjiku = "周期 (sec)";
                    break;
            }
            df = 1.0 / dt / (double)nn;

            //画像書き出し
            kpt = 2;
            for (jj = 0; jj <= 4; jj++)
            {
                switch (jj)
                {
                    case 0:
                        fnameD = wn0[icase - 1] + "_" + "figfs01.png";
                        for (i = 0; i <= nd; i++) { datay[i] = fs01[i]; }
                        band = 0.0;
                        comR = strcom1[icase - 1];
                        break;
                    case 1:
                        fnameD = wn0[icase - 1] + "_" + "figfs02.png";
                        for (i = 0; i <= nd; i++) { datay[i] = fs02[i]; }
                        band = 0.0;
                        comR = strcom2[icase - 1];
                        break;
                    case 2:
                        fnameD = wn0[icase - 1] + "_" + "figfsp1.png";
                        for (i = 0; i <= nd; i++) { datay[i] = fsp1[i]; }
                        band = double.Parse(toolStripTextBox1.Text);
                        comR = strcom1[icase - 1];
                        break;
                    case 3:
                        fnameD = wn0[icase - 1] + "_" + "figfsp2.png";
                        for (i = 0; i <= nd; i++) { datay[i] = fsp2[i]; }
                        band = double.Parse(toolStripTextBox1.Text);
                        comR = strcom2[icase - 1];
                        break;
                    case 4:
                        fnameD = wn0[icase - 1] + "_" + "figfspr.png";
                        for (i = 0; i <= nd; i++) { datay[i] = fspr[i]; }
                        band = double.Parse(toolStripTextBox1.Text);
                        comR = strcom1[icase - 1] + "／" + strcom2[icase - 1];
                        break;
                }
                switch (jj)
                {
                    case 4:
                        syjiku = "フーリエスペクトル比";
                        break;
                    default:
                        switch (slog[icase - 1])
                        {
                            case "N": syjiku = "フーリエスペクトル"; break;
                            case "L": syjiku = "フーリエスペクトル (gal*sec)"; break;
                        }
                        break;
                }
                switch (slog[icase - 1])
                {
                    case "N":
                        for (i = 0; i <= nd; i++) { datax[i] = fq[i]; }
                        fsmax = datay[0];
                        for (i = 0; i <= nd; i++)
                        {
                            if (fsmax <= datay[i]) fsmax = datay[i];
                        }
                        for (i = 0; i <= nd; i++) { datay[i] = datay[i] / fsmax; }
                        break;
                    case "L":
                        for (i = 1; i <= nd; i++) { datax[i] = Math.Log10(1.0 / fq[i]); }
                        datax[0] = datax[1] * 2.0;
                        for (i = 0; i <= nd; i++) { datay[i] = Math.Log10(datay[i]); }
                        fsmax = datay[0];
                        for (i = 0; i <= nd; i++)
                        {
                            if (fsmax <= datay[i]) fsmax = datay[i];
                        }
                        fsmax = Math.Pow(10, fsmax);
                        break;
                }

                pictureBox1.Size = new Size(kpt * HSIZE, kpt * VSIZE);
                pictureBox1.Visible = false;
                bmp = new Bitmap(pictureBox1.Width, pictureBox1.Height);
                pictureBox1.Image = bmp;
                g = Graphics.FromImage(pictureBox1.Image);
                g.FillRectangle(Brushes.White, 0, 0, pictureBox1.Width, pictureBox1.Height);
                PLOT(g, kpt, sxjiku, syjiku, figxmin, figxmax, figdx, figymin, figymax, figdy,
                     kxi0, kxf0, kyi0, kyf0, nd, datax, datay, slog[icase - 1], slog[icase - 1], band, fsmax, comR);
                fnameD = System.IO.Path.GetDirectoryName(fnameR) + "\\" + fnameD;
                pictureBox1.Image.Save(fnameD, System.Drawing.Imaging.ImageFormat.Png);
                g.Dispose();
            }
        }
        //------------------------------------------------------------------------------
        private void FFT(int nn, double[] xr, double[] xi)
        {
            //**************************************
            //高速フーリエ変換・逆変換
            //**************************************
            //nn  ：データ数（2の累乗）
            //xr[]：入出力データ実数部
            //xi[]：入出力データ虚数部

            int g, h, i, j, k, l, m, n, p, q;
            double a, b, xd;

            n = nn;
            double[] s = new double[(int)(n/2)+1];
            double[] c = new double[(int)(n/2)+1];

            i = 0; j = 0; k = 0; l = 0; p = 0; h = 0; g = 0; q = 0;
            m = (int)(Math.Log((double)n) / Math.Log(2.0)+1.0);
            a = 0.0;
            b = Math.PI * 2.0 / (double)n;
            for (i = 0; i <= (int)(n / 2); i++)
            {
                s[i] = Math.Sin(a);
                c[i] = Math.Cos(a);
                a = a + b;
            }
            l = n; h = 1;
            for (g = 1; g <= m; g++)
            {
                l = (int)(l / 2); k = 0;
                for (q = 1; q <= h; q++)
                {
                    p = 0;
                    for (i = k; i <= l + k - 1; i++)
                    {
                        j = i + l;
                        a = xr[i] - xr[j];
                        b = xi[i] - xi[j];
                        xr[i] = xr[i] + xr[j];
                        xi[i] = xi[i] + xi[j];
                        if (p == 0)
                        {
                            xr[j] = a;
                            xi[j] = b;
                        }
                        else
                        {
                            xr[j] = a * c[p] + b * s[p];
                            xi[j] = b * c[p] - a * s[p];
                        }
                        p = p + h;
                    }
                    k = k + l + l;
                }
                h = h + h;
            }
            j = (int)(n / 2);
            for (i = 1; i <= n - 1; i++)
            {
                k = n;
                if (j < i)
                {
                    xd = xr[i]; xr[i] = xr[j]; xr[j] = xd;
                    xd = xi[i]; xi[i] = xi[j]; xi[j] = xd;
                }
                k = (int)(k / 2);
                while (j >= k)
                {
                    j = j - k; k = (int)(k / 2);
                    if (k == 0) break;
                }
                j = j + k;
            }
        }
        //---------------------------------------------------------------------------------

        private void IACC(int nn, double dt, double[] ddy, double[] dy, double[] y,
                          out double ddymax, out double dymax, out double ymax)
        {
            //**************************************
            //加速度時刻歴数値積分
            //**************************************
            //nn:加速度時刻歴データ総数
            //dt    :時間間隔（入力値）
            //ddy[] :加速度時刻歴（入力値）
            //dy[]  :速度時刻歴（計算出力）
            //y[]   :変位時刻歴（計算出力値）
            //ddymax:加速度最大値（計算出力値）
            //dymax :速度最大値（計算出力値）
            //ymax  :変位最大値（計算出力値）

            int i;

            ddymax = 0.0;
            dymax = 0.0;
            ymax = 0.0;
            dy[0] = 0.0;
            y[0] = 0.0;
            for (i = 1; i <= nn - 1; i++)
            {
                dy[i] = dy[i - 1] + (ddy[i - 1] + ddy[i]) * dt / 2.0;
                y[i] = y[i - 1] + dy[i - 1] * dt + (ddy[i - 1] / 3.0 + ddy[i] / 6.0) * dt * dt;
                if (ddymax < Math.Abs(ddy[i])) ddymax = Math.Abs(ddy[i]);
                if (dymax < Math.Abs(dy[i])) dymax = Math.Abs(dy[i]);
                if (ymax < Math.Abs(y[i])) ymax = Math.Abs(y[i]);
            }
        }
        //---------------------------------------------------------------------------
        private void CRAC(int nn, double dt, double[] ddy, double[] dy, double[] y,
                          double ddymax, double dymax, double ymax)
        {
            //**************************************
            //加速度時刻歴基線補正
            //**************************************
            //nn:加速度時刻歴データ総数
            //dt    :時間間隔（入力値）
            //ddy[] :加速度時刻歴（入力値・書換出力値）
            //dy[]  :速度時刻歴（入力値）
            //y[]   :変位時刻歴（入力値）
            //ddymax:加速度最大値（入力値）
            //dymax :速度最大値（入力値）
            //ymax  :変位最大値（入力値）

            int i;
            double tt, t, sum, a1, a0, acmax, coef;

            tt = (double)(nn - 1) * dt;
            t = 0.0;
            for (i = 0; i <= nn - 1; i++)
            {
                y[i] = y[i] * (3.0 * tt - 2.0 * t) * t * t;
                t = t + dt;
            }
            sum = (y[0] + y[nn - 1]) / 2.0;
            for (i = 1; i <= nn - 2; i++)
            {
                sum = sum + y[i];
            }
            sum = sum * dt;
            a1 = 28.0 / 13.0 / tt / tt * (2.0 * dy[nn - 1] - 15.0 / Math.Pow(tt, 5.0) * sum);
            a0 = dy[nn - 1] / tt - a1 / 2.0 * tt;
            t = 0.0;
            acmax = 0.0;
            for (i = 0; i <= nn - 1; i++)
            {
                ddy[i] = ddy[i] - a0 - a1 * t;
                if (acmax < Math.Abs(ddy[i])) acmax = Math.Abs(ddy[i]);
                t = t + dt;
            }
            coef = ddymax / acmax;
            for (i = 0; i <= nn - 1; i++)
            {
                ddy[i] = ddy[i] * coef;
            }
        }
        //---------------------------------------------------------------------------

        private void SWIN(int nn, double[] fs, double df, double band)
        {
            //**************************************
            //スペクトル平滑化
            //**************************************
            //nn   ：時刻歴全数
            //fs() ：フーリエ・スペクトル
            //df   ：スペクトルの振動数間隔（Hz）
            //band ：バンド幅（Hz）
            //nfold：スペクトル値総数

            double pi = Math.PI;
            double tt, udf, dif, s;
            int i, j;
            int nfold, lmax, ll, ln, lt, le;
            double[] w = new double[nn];
            double[] g = new double[nn];
            double[] g1 = new double[nn];
            double[] g2 = new double[nn];

            nfold = (int)(nn / 2) + 1;

            if (band > 0.0)
            {
                tt = 1.0 / df;
                udf = 280.0 / 151.0 / band * df;
                lmax = (int)(2.0 / udf) + 1;

                if (udf <= 0.5)
                {
                    w[0] = 0.75 * udf;
                    for (i = 2; i <= lmax; i++)
                    {
                        dif = 0.5 * pi * (double)(i - 1) * udf;
                        w[i - 1] = w[0] * Math.Pow(Math.Sin(dif) / dif, 4.0);
                    }
                    g[0] = fs[0] * fs[0] / tt;
                    for (i = 2; i <= nfold - 1; i++)
                    {
                        g[i - 1] = 2.0 * fs[i - 1] * fs[i - 1] / tt;
                    }
                    g[nfold - 1] = fs[nfold - 1] * fs[nfold - 1] / tt;
                    ll = lmax * 2 - 1;
                    ln = ll - 1 + nfold;
                    lt = (ll - 1) * 2 + nfold;
                    le = lt - lmax + 1;
                    for (i = 1; i <= lt; i++)
                    {
                        g1[i - 1] = 0.0;
                    }
                    for (i = 1; i <= nfold; i++)
                    {
                        g1[ll - 2 + i] = g[i - 1];
                    }
                    for (i = lmax; i <= le; i++)
                    {
                        s = w[0] * g1[i - 1];
                        for (j = 2; j <= lmax; j++)
                        {
                            s = s + w[j - 1] * (g1[i - j] + g1[i + j - 2]);
                        }
                        g2[i - 1] = s;
                    }
                    for (j = 2; j <= lmax; j++)
                    {
                        g2[ll + j - 2] = g2[ll + j - 2] + g2[ll - j];
                        g2[ln - j] = g2[ln - j] + g2[ln + j - 2];
                    }
                    for (i = 1; i <= nfold; i++)
                    {
                        g[i - 1] = g2[ll - 2 + i];
                    }
                    fs[0] = Math.Sqrt(g[0] * tt);
                    for (i = 2; i <= nfold - 1; i++)
                    {
                        fs[i - 1] = Math.Sqrt(g[i - 1] * tt / 2.0);
                    }
                    fs[nfold - 1] = Math.Sqrt(g[nfold - 1] * tt);
                }
            }
        }
        //------------------------------------------------------------------------------

        private void PLOT(Graphics g, int kpt, string sxjiku, string syjiku,
             double xmin, double xmax, double dx, double ymin, double ymax, double dy,
             int kxi0, int kxf0, int kyi0, int kyf0, int nd, double[] datax, double[] datay,
             string slogx, string slogy, double band, double fsmax, string comR)
        {

            int i, j, kxi, kxf, kyi, kyf, kxx, kyy, kxx1, kyy1, kxx2, kyy2;
            double xx, yy;
            string str;
            Font f = new Font("ＭＳ ゴシック", kpt * 16, FontStyle.Bold);
            System.Drawing.SizeF TextSize1;
            System.Drawing.SizeF TextSize2;

            kxi = kpt * kxi0; kxf = kpt * kxf0; kyi = kpt * kyi0; kyf = kpt * kyf0;

            //座標軸
            System.Drawing.Pen LPen = new System.Drawing.Pen(System.Drawing.Color.Black);
            LPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Dot;
            if(slogx=="N")DRN_XJIKU(g, f, LPen, kpt, xmin, xmax, dx, kxi, kxf, kyi, kyf);
            if(slogy=="N")DRN_YJIKU(g, f, LPen, kpt, ymin, ymax, dy, kxi, kxf, kyi, kyf);
            if(slogx=="L")DRL_XJIKU(g, f, LPen, kpt, xmin, xmax, kxi, kxf, kyi, kyf);
            if(slogy=="L")DRL_YJIKU(g, f, LPen, kpt, ymin, ymax, kxi, kxf, kyi, kyf);
            //枠線描画
            g.DrawRectangle(new Pen(Color.Black, 2), kxi, kyi, kxf - kxi, kyf - kyi);
            //ｙ軸名描画
            str = syjiku;
            TextSize2 = g.MeasureString(str, f);
            TextSize1 = g.MeasureString("-1.0", f);
            kxx = (int)(kxi - kpt * 10 - TextSize1.Width - TextSize2.Height);
            kyy = (int)((kyi + kyf) / 2 + TextSize2.Width / 2);
            INC_STR(g, f, str, kxx, kyy, -90);
            //ｘ軸名描画
            str = sxjiku;
            TextSize2 = g.MeasureString(str, f);
            kxx = (int)((kxi + kxf) / 2 - TextSize2.Width / 2);
            kyy = (int)(kyf + kpt * 10 + TextSize1.Height);
            INC_STR(g, f, str, kxx, kyy, 0);
            //データを線で連結
            xx = datax[0];
            yy = datay[0];
            if (xx < xmin) xx = xmin;
            if (xmax < xx) xx = xmax;
            if (yy < ymin) yy = ymin;
            if (ymax < yy) yy = ymax;
            kxx1 = kxi + (int)((xx - xmin) * (kxf - kxi) / (xmax - xmin));
            kyy1 = kyf - (int)((yy - ymin) * (kyf - kyi) / (ymax - ymin));
            for (i = 1; i <= nd; i++)
            {
                xx = datax[i];
                yy = datay[i];
                if (xx < xmin) xx = xmin;
                if (xmax < xx) xx = xmax;
                if (yy < ymin) yy = ymin;
                if (ymax < yy) yy = ymax;
                kxx2 = kxi + (int)((xx - xmin) * (kxf - kxi) / (xmax - xmin));
                kyy2 = kyf - (int)((yy - ymin) * (kyf - kyi) / (ymax - ymin));
                g.DrawLine(new Pen(Color.Blue, 2), kxx1, kyy1, kxx2, kyy2);
                kxx1 = kxx2;
                kyy1 = kyy2;
            }

            int nfp;
            int[] kfp = new int[nd];

            //極大値となる周波数
            j = -1;
            for (i = 1; i <= nd - 1; i++)
            {
                if (datay[i - 1] < datay[i] && datay[i] > datay[i + 1])
                { //極大値となる番号の検索
                    j = j + 1; kfp[j] = i;
                }
            }
            nfp = j;

            int k;
            double[] wx = new double[nfp + 1];
            double[] wy = new double[nfp + 1];
            for (i = 0; i <= nfp; i++)
            {
                wx[i] = datax[kfp[i]];
                wy[i] = datay[kfp[i]];
            }
            SORT(nfp, wx, wy); //大きい順の並び替え

            if (0.0001 < band)
            {
                f = new Font("ＭＳ ゴシック", kpt * 12, FontStyle.Italic);
                j = -1;
                k = 0;
                do
                {
                    j = j + 1;
                    if (nfp < j) break;
                    xx = wx[j];
                    yy = wy[j];
                    if (Math.Log10(0.05) <= xx)
                    {
                        if (xx <= xmax)
                        {
                            k = k + 1;
                            kxx = kxi + (int)((xx - xmin) * (kxf - kxi) / (xmax - xmin));
                            kyy = kyf - (int)((yy - ymin) * (kyf - kyi) / (ymax - ymin));
                            switch (slogx)
                            {
                                case "N": str = xx.ToString("0.000"); break;
                                case "L": str = (Math.Pow(10, xx)).ToString("0.000"); break;
                            }
                            TextSize2 = g.MeasureString(str, f);
                            kxx=kxx -(int)(TextSize2.Height / 2);
                            kyy = kyy - 1 * kpt;
                            INC_STR(g,  f, str, kxx, kyy, -90);
                        }
                    }
                } while (k <= 10);
            }

            f = new Font("ＭＳ ゴシック", kpt * 16, FontStyle.Bold);
            str = "バンド幅：" + band.ToString("0.0") + " Hz";
            if (band < 0.0001) str = "原波形";
            TextSize2 = g.MeasureString(str, f);
            g.DrawString(str, f, Brushes.Black, kxf - TextSize2.Width - 5 * kpt, kyi + 5 * kpt);
            if ((syjiku=="フーリエスペクトル") || (syjiku=="フーリエスペクトル (gal*sec)"))
            {
                str = "max;" + fsmax.ToString("0") + "(gal*sec)";
            }
            if (syjiku=="フーリエスペクトル比") str = "max;" + fsmax.ToString("0.000");
            TextSize2 = g.MeasureString(str, f);
            g.DrawString(str, f, Brushes.Black, kxf - TextSize2.Width - 5 * kpt, kyi - 25 * kpt);
            g.DrawString(comR, f, Brushes.Black, kxi + 5 * kpt, kyi - 25 * kpt);

            f.Dispose();

        }
        //------------------------------------------------------------------------------

        private void SORT(int nd, double[] xd, double[] yd)
        {
            int i, j;
            double work;
            //ydの大きい順でのソート
            for (i = 0; i <= nd - 1; i++)
            {
                for (j = i + 1; j <= nd; j++)
                {
                    if (yd[i] < yd[j])
                    {
                        work = xd[i]; xd[i] = xd[j]; xd[j] = work;
                        work = yd[i]; yd[i] = yd[j]; yd[j] = work;
                    }
                }
            }
        }
        //------------------------------------------------------------------------------
        //------------------------------------------------------------------------------
        private void INC_STR(Graphics g, System.Drawing.Font f, string str, int kxx, int kyy, float ang)
        {
            //軸名描画
            g.ScaleTransform(1, 1);//横・縦の表示比率を設定
            g.TranslateTransform(kxx, kyy);//表示位置の設定（表示位置を原点とする座標移動）
            g.RotateTransform(ang);//表示角度を指定
            g.DrawString(str, f, Brushes.Black, 0, 0);//描画実行
            g.ResetTransform();//単位行列にリセット
        }
        //---------------------------------------------------------------------------------
        private void DRN_XJIKU(Graphics g, System.Drawing.Font f, System.Drawing.Pen LPen,
                int kpt, double xmin, double xmax, double dx, int kxi, int kxf, int kyi, int kyf)
        {
            int i, ix, kxx;
            double xx, wv;
            string str;
            System.Drawing.SizeF TextSize1;
            //普通ｘ軸描画
            ix = (int)((xmax - xmin) / dx);
            for (i = 0; i <= ix; i++)
            {
                xx = xmin + (double)(i) * dx;
                kxx = kxi + (int)((xx - xmin) * (kxf - kxi) / (xmax - xmin));
                wv = xmin + (double)(i) * dx;
                str = wv.ToString("0");
                if ((int)(dx * 1000.0) % 10 != 0) { str = wv.ToString("0.000"); }
                if ((int)(dx * 1000.0) % 10 == 0 && (int)(dx * 100.0) % 10 != 0) { str = wv.ToString("0.00"); }
                if ((int)(dx * 1000.0) % 10 == 0 && (int)(dx * 100.0) % 10 == 0 && (int)(dx * 10.0) % 10 != 0) { str = wv.ToString("0.0"); }
                TextSize1 = g.MeasureString(str, f);
                g.DrawLine(LPen, kxx, kyi, kxx, kyf);
                g.DrawString(str, f, Brushes.Black, kxx - TextSize1.Width / 2, kyf + kpt * 3);
            }
        }
        //---------------------------------------------------------------------------------
        private void DRN_YJIKU(Graphics g, System.Drawing.Font f, System.Drawing.Pen LPen, int kpt,
                               double ymin, double ymax, double dy, int kxi, int kxf, int kyi, int kyf)
        {
            int i, iy, kyy;
            double yy, wv;
            string str;
            System.Drawing.SizeF TextSize1;
            //普通ｙ軸描画
            iy = (int)((ymax - ymin) / dy);
            for (i = 0; i <= iy; i++)
            {
                yy = ymin + (double)(i) * dy;
                kyy = kyf - (int)((yy - ymin) * (kyf - kyi) / (ymax - ymin));
                wv = ymin + (int)(i) * dy;
                str = wv.ToString("0");
                if ((int)(dy * 1000.0) % 10 != 0) { str = wv.ToString("0.000"); }
                if ((int)(dy * 1000.0) % 10 == 0 && (int)(dy * 100.0) % 10 != 0) { str = wv.ToString("0.00"); }
                if ((int)(dy * 1000.0) % 10 == 0 && (int)(dy * 100.0) % 10 == 0 && (int)(dy * 10.0) % 10 != 0) { str = wv.ToString("0.0"); }
                TextSize1 = g.MeasureString(str, f);
                g.DrawLine(LPen, kxi, kyy, kxf, kyy);
                g.DrawString(str, f, Brushes.Black, kxi - TextSize1.Width - kpt * 2, kyy - TextSize1.Height / 2);
            }
        }
        //---------------------------------------------------------------------------------
        private void DRL_XJIKU(Graphics g, System.Drawing.Font f, System.Drawing.Pen LPen,
                               int kpt, double xmin, double xmax, int kxi, int kxf, int kyi, int kyf)
        {
            int i, j, kxx;
            double xx;
            string str;
            System.Drawing.SizeF TextSize1;
            //対数ｘ軸描画
            for (i = (int)(xmin); i <= (int)xmax - 1; i++)
            {
                for (j = 1; j <= 9; j++)
                {
                    xx = Math.Log10((double)(j) * Math.Pow(10.0, (double)i));
                    kxx = kxi + (int)((xx - xmin) * (kxf - kxi) / (xmax - xmin));
                    g.DrawLine(LPen, kxx, kyi, kxx, kyf);
                }
            }
            for (i = (int)xmin; i <= (int)xmax; i++)
            {
                xx = (double)i;
                kxx = kxi + (int)((xx - xmin) * (kxf - kxi) / (xmax - xmin));
                str = Math.Pow(10.0, (double)i).ToString();
                TextSize1 = g.MeasureString(str, f);
                g.DrawString(str, f, Brushes.Black, kxx - TextSize1.Width / 2, kyf + kpt * 3);
            }
        }
        //---------------------------------------------------------------------------------
        private void DRL_YJIKU(Graphics g, System.Drawing.Font f, System.Drawing.Pen LPen,
                                int kpt, double ymin, double ymax, int kxi, int kxf, int kyi, int kyf)
        {
            int i, j;
            double yy;
            string str;
            int kyy;
            System.Drawing.SizeF TextSize1;
            //対数ｙ軸描画
            for (i = (int)ymin; i <= (int)ymax - 1; i++)
            {
                for (j = 1; j <= 9; j++)
                {
                    yy = Math.Log10((double)j * Math.Pow(10.0, (double)i));
                    kyy = kyf - (int)((yy - ymin) * (kyf - kyi) / (ymax - ymin));
                    g.DrawLine(LPen, kxi, kyy, kxf, kyy);
                }
            }
            for (i = (int)ymin; i <= (int)ymax; i++)
            {
                yy = (double)i;
                kyy = kyf - (int)((yy - ymin) * (kyf - kyi) / (ymax - ymin));
                str = (Math.Pow(10.0, (double)i)).ToString();
                TextSize1 = g.MeasureString(str, f);
                g.DrawString(str, f, Brushes.Black, kxi - TextSize1.Width - kpt * 2, kyy - TextSize1.Height / 2);
            }
        }
        //---------------------------------------------------------------------------------
    
    }
}