int max = _maxValue < 0 ? 0 : _maxValue;

                                   Graphics g = null;

                                   _bitmap = new Bitmap(2 * _data.Length, min + max);

                                   g = Graphics.FromImage(_bitmap);

                                   g.FillRectangle(new SolidBrush(Color.White), g.ClipBounds);

                                   for(int i = 1; i <= _data.Length; i++)

                                   {

                                          g.DrawLine(new Pen(Color.Black),

                                                  new Point(2*i-1 , max),

                                                  new Point(2*i-1, max - _data[i-1]));

                                   }

                            }

                            return _bitmap;

                    }

             }

             public void Clean()

             {

                    _data = new int[0];

                    _minValue = int.MaxValue;

                    _maxValue = int.MinValue;

             }

             public bool IsEmpty

            {

                    get { return _data.Length == 0; }

             }

             public int this[int index]

             {

                    get { return _data[index]; }

                    set { sorter = _data[index] = value; }

             }

             private int sorter

             {

                    set

                    {

                            DataUtil.Sort(value, ref _minValue, ref _maxValue);

                    }

            }

             public IEnumerator GetEnumerator()

             {

                    return _data.GetEnumerator();

             }

             public int Length

             {

                    get { return _data.Length; }

             }

             public void CopyTo(int[] arr)

             {

                    _data.CopyTo(arr, 0);

             }

     }

}

П. 1.2. ТЕКСТ МОДУЛЯ WAVELET.CS

using MultiScAn.Common.Classes;

namespace MultiScAn.WaveletAnalysis

{

     /// <summary>

     /// Summary description for Wavelet.

     /// </summary>

     public class Wavelet : Signal

     {

             public Wavelet()

             {

             }

             public double[] Resample(int size)

             {

                    double[] res = new double[size];

                    for (int i = 0, offs = 0; i < size; i++, offs += base.Length)

                    {

                            res[i] = 0.0;

                            for (int j = 0; j < base.Length; j++)

                            {

                                   res[i] += base[(offs + j)/size];

                            }

                            res[i] /= base.Length;

                    }

                    return res;

             }

     }

}

П. 1.3. ТЕКСТ МОДУЛЯ RESULT.CS

using System;

using System.Collections;

using System.Drawing;

using System.IO;

using MultiScAn.Common.Attributes;

using MultiScAn.Common.Classes;

using MultiScAn.Common.Interfaces;

using MultiScAn.Common.Utils;

namespace MultiScAn.WaveletAnalysis

{

     /// <summary>

     /// Summary description for ResultUtil.

     /// </summary>

     [Filter("Результат вейвлет анализа (*.war)|*.war")]

     public class Result : IResult

     {

             double [,] _Data = new double[0, 0];

             private Bitmap _bitmap;

             private double _minValue = double.MaxValue;

             private double _maxValue = double.MinValue;

             private Spectrum _spectrum = new Spectrum();

             public Result()

             {

             }

             internal void Rebuild(int height, int width)

             {

                    _bitmap = null;

                    _Data = new double[height, width];

                    _minValue = double.MaxValue;

                    _maxValue = double.MinValue;

             }

             public int Width

             {

                    get { return _Data.GetLength(1); }

             }

             public int Height

             {

                    get { return _Data.GetLength(0); }

             }

             public double this[int i, int j]

             {

                    get { return _Data[i, j]; }

                    set { sorter = _Data[i, j] = value; }

             }

             public double MinValue

             {

                    get { return _minValue; }

             }

             public double MaxValue

             {

                    get { return _maxValue; }

             }

             public void Load(string fileName)

             {

                    double min = double.MaxValue, max = double.MinValue;

                    double [,] data;

                    using(StreamReader reader = File.OpenText(fileName))

                    {

                            int width = int.Parse(__read(reader));

                            int height = int.Parse(__read(reader));

                            data = new double[width, height];

                            for(int i = 0; i < width; i++)

                            {

                                   for(int j = 0; j < height; j++)

                                   {

                                          DataUtil.Sort(data[i, j] = double.Parse(__read(reader)), ref min, ref max);

                                   }

                            }

                    }

                    _Data = data;

                    _minValue = min;

                    _maxValue = max;

                    _bitmap = null;

                    if(OnLoad != null) OnLoad();

             }

             private string __read(StreamReader reader)

             {

            string str = reader.ReadLine();

                    if (str == null) throw new NotSupportedException();

                    return str;

             }

             public event CommonHandler OnLoad;

             public void Save(string fileName)

             {

                    using(StreamWriter writer = File.CreateText(fileName))

                    {

                            int height = _Data.GetLength(0), width = _Data.GetLength(1);

                            writer.WriteLine(height);

                            writer.WriteLine(width);

                            for(int i = 0; i < height; i++)

                            {

                                   for(int j = 0; j < width; j++)

                                   {

                        writer.WriteLine(_Data[i, j]);                                                 

                                   }

                            }

                    }

                    if (OnSave != null) OnSave();

             }

             public event CommonHandler OnSave;

             public Bitmap Bitmap

             {

                    get

                    {

                            if (_bitmap == null)

                            {

                                   if (_spectrum.Length == 0) _spectrum.LoadDefault();

                                   _bitmap = new Bitmap(Width, Height);

                                   double k = (_spectrum.Length - 1) / (_maxValue - _minValue);

                                   for(int i = 0; i < Height; i++)

                                   {

                                          for(int j = 0; j < Width; j++)

                                          {

                                                  _bitmap.SetPixel(j, i, _spectrum[(int) (k *(_Data[i, j] - _minValue))]);

                                          }

                                   }

                            }

                            return _bitmap;

                    }

             }

             public void FormRow(Signal x, double[] y, int row)

             {

                    int result_size = 2 * x.Length,

                            max_offset = x.Length - y.Length,

                            null_offset = Math.Min(y.Length - 1, result_size);

                    if (result_size != _Data.GetLength(1)) throw new ArgumentOutOfRangeException();

                    for (int i = 0; i < null_offset; i++)

                    {

                            this[row, i] = 0.0;

                    }

                    if (null_offset == result_size) return; // зачем делать лишние движения, если и так уже всё забито нулями

                    for (int i = 0; i <= max_offset; i++)

                    {

                            double sum = 0.0;

                            for (int j = 0; j < y.Length; j++)

                            {

                                   sum += x[i+j] * y[j];

                            }            

                            this[row, 2*i+y.Length-1] = sum;

                            this[row, 2*i+y.Length] = 0.0;

                    }     

                    for (int i = result_size - null_offset; i < result_size; i++)

                    {

                            this[row, i] = 0.0;

                    }

             }

             public Spectrum Spectrum

             {

Страницы: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14