Esempio n. 1
0
 private void ButtonFAnalysis_Click(object sender, EventArgs e)
 {
     if (pixelsTemp != null)
     {
         Stopwatch timer = new Stopwatch();
         timer.Start();
         Base_fract_anal fractAnal = procedures.FractalDimension(pixelsTemp, (int)numericUpDownCountMeasure.Value,
                                                                 (int)numericUpDownMeasureOne.Value, checkBoxRelativeOrAbsolute.CheckState == CheckState.Checked,
                                                                 toolStripProgressBarCalculate);
         richTextBoxAresult.Text += "\n" + fractAnal.ToString(fractAnal.FractalDimensionSquare);
         timer.Stop();
         TimeSpan ts = timer.Elapsed;
         toolStripStatusLabelInpho.Text = "Фрактальный анализ выполнен за: " + ts.Minutes + " м. :" +
                                          ts.Seconds + " с." + ts.Milliseconds +
                                          " мс. (общее количество миллисекунд - " + ts.TotalMilliseconds;
     }
     else
     {
         MessageBox.Show("Отсутствуют исходные данные.", "Ошибка!");
     }
 }
Esempio n. 2
0
        static List <int> iScale = new List <int>();           //Количество мер

        /// <summary>
        /// Определение фрактальной размерности выделенных пикселей
        /// </summary>
        /// <param name="listE">Список пикселей изображения</param>
        /// <param name="CountFractalAnalysis">Количество фрактальных размерностей</param>
        /// <param name="m">Размер меры (масштаба)</param>
        /// <param name="absOrRelR">Абсолютное или относительное значение меры</param>
        /// <returns></returns>
        public Base_fract_anal FractalDimension(List <Pixels> listE, int CountFractalAnalysis,
                                                int m, bool absOrRelR, ToolStripProgressBar progressCalculate)
        {
            Base_fract_anal ResultFractalAnalysis = new Base_fract_anal();

            if (listE.Count < 3)
            {
                return(ResultFractalAnalysis);
            }

            ResultFractalAnalysis.FractalDimensionSquare = new List <float>();
            ResultFractalAnalysis.CountSquare            = new List <int>();;
            ResultFractalAnalysis.SizeSquare             = new List <float>();
            ResultFractalAnalysis.PointS        = new List <FractalMeraS>();
            ResultFractalAnalysis.CountElements = listE.Count();
            List <PointF> listPointF = new List <PointF>();
            int           mera;                           //Масштаб измерения

            int[]   LS = new int[CountFractalAnalysis];   // Размерность контура (количество клеток-мер)
            float[] MS = new float[CountFractalAnalysis]; // Мера для метода клеток

            //Клеточный метод определения фрактальной размерности
            //Мин. и макс. координат изображения
            float xmin = 0, xmax = listE.Select(s => s.X).Max();
            float ymin = 0, ymax = listE.Select(s => s.Y).Max();

            // Первоначальный размер клетки
            if (absOrRelR)
            {
                mera = m;
            }             //абсолютный размер
            else
            {
                mera = (int)(((xmax - xmin) + (ymax - ymin)) / (2 * m));
            }                                                            //клетка относительно среднеарифметического для размеров изображения
            ResultFractalAnalysis.Mstart = mera;
            //Изменение меры
            for (int varMera = 0; varMera < CountFractalAnalysis; varMera++)
            {
                //int iSquare = 0; // Количество клеток содержащих выделенные пиксели
                List <PointF> listSquare = new List <PointF>(); //Список клеток (клетка задана двумя точками - t1(xmin,ymin), t2(xmax,ymax))
                float         x          = 0;
                while (x < xmax)
                {
                    float y = 0;
                    while (y < ymax)
                    {
                        listSquare.Add(new PointF()
                        {
                            X = x, Y = y
                        });
                        y += mera;
                    }
                    x += mera;
                }
                List <PointF>[] listSquareForPrCount = new List <PointF> [countProc];
                int             range = listSquare.Count / countProc + 1;
                for (int i = 0; i < countProc; i++)
                {
                    listSquareForPrCount[i] = listSquare.GetRange(i * range,
                                                                  (i + 1) * range > listSquare.Count ? listSquare.Count - i * range : range);
                    DataCalculate dataTemp = new DataCalculate()
                    {
                        iRange     = i,
                        dmera      = mera,
                        listPixels = listE,
                        listPoint  = listSquareForPrCount[i]
                    };
                    new Thread(ScaleRange).Start(dataTemp);
                    Thread.Sleep(0);
                }
                while (iScale.Count() != countProc)
                {
                    Thread.Sleep(500);
                }
                LS[varMera] = iScale.Sum();
                iScale.Clear();

                /*
                 * // Определяем количество клеток
                 * foreach (var itemS in listSquare)
                 * {
                 *  int pointInSquare = listE.Count(p => p.X >= itemS.X && p.Y >= itemS.Y && p.X < itemS.X + mera && p.Y < itemS.Y + mera);
                 *  if (pointInSquare >= 1 && pointInSquare < mera * mera)
                 *  {
                 *      LS[varMera]++;
                 *  }
                 *
                 *  //ProgressBarRefresh(progressCalculate, varMera + i++/listSquare.Count(), CountFractalAnalysis);
                 *  //
                 *  foreach (var itemE in listE)
                 *  {
                 *      if (itemE.X >= itemS.X && itemE.Y >= itemS.Y && itemE.X < itemS.X + mera && itemE.Y < itemS.Y + mera)
                 *      {
                 *         LS[varMera]++;
                 *         break;
                 *      }
                 *  }
                 *  //
                 * }
                 */
                MS[varMera] = mera;
                if (varMera > 0)
                {
                    ResultFractalAnalysis.FractalDimensionSquare.Add((float)((Math.Log(LS[varMera - 1]) - Math.Log(LS[varMera])) /
                                                                             (Math.Log(MS[varMera] / MS[varMera - 1]))));
                }
                ResultFractalAnalysis.SizeSquare.Add(MS[varMera]);
                ResultFractalAnalysis.CountSquare.Add(LS[varMera]);
                mera /= 2;
                ProgressBarRefresh(progressCalculate, varMera + 1, CountFractalAnalysis);
            }
            return(ResultFractalAnalysis);
        }