Esempio n. 1
0
        private void buttonSelectedDown_Click(object sender, EventArgs e)
        {
            int level     = -1; //расположение 0-выбран узел линии, 1-точка линии
            int pos       = -1; // если это линия то её индекс, если точка то её индекс
            int posParent = -1; //если выбрана точка, то тут индекс линии

            if (treeViewVectors.SelectedNode == null)
            {
                return;
            }

            level = treeViewVectors.SelectedNode.Level;
            pos   = treeViewVectors.SelectedNode.Index;


            if (level != 0)
            {
                return;
            }

            if (pos == pageVectorNOW.Count - 1)
            {
                return;
            }

            GroupPoint ggp = pageVectorNOW[pos].Clone();

            pageVectorNOW.RemoveAt(pos);
            pageVectorNOW.Insert(pos + 1, ggp.Clone());


            UserActions();


            treeViewVectors.SelectedNode           = treeViewVectors.Nodes[pos + 1];
            treeViewVectors.SelectedNode.ForeColor = Color.Blue;
            //treeViewVectors.SelectedNode.NodeFont = new Font(this.Font, FontStyle.Bold);
        }
        //
        private void GenNewVar3()
        {
            // работа заточена только под 24-х битный пиксель
            if (pageImageNOW.PixelFormat != PixelFormat.Format24bppRgb)
            {
                //throw new UnsupportedImageFormatException("Оппа! Не поддерживаемый формат изображения!!!");
                MessageBox.Show(@"Для генерации данных, требуется изображение имеющее 24 бита на пиксель, а получилось иначе, очень подозрительно....!!");
                return;
            }

            #region Переменные для алгоритма

            BitmapData bitmapData1 = pageImageNOW.LockBits(new Rectangle(0, 0, pageImageNOW.Width, pageImageNOW.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);

            // для понимания того в какой точке изображения находимся
            int posX     = 0;
            int posY     = bitmapData1.Height - 1;
            int posYreal = 0;

            //узнаем объем анализируемого изображения
            int CountPoint = bitmapData1.Height * bitmapData1.Width;

            double sizeOnePoint = (double)numSizePoint.Value;

            #endregion

            // для хранения цвета текущей полученной точки
            int currColor = -1; // текущий цвет
            int lastColor = -1; // предыдущий цвет отрезка

            //bool StartCaptureLine = false;
            bool isFirstPoint = true;

            // очистим текущий набор
            pageVectorNOW = new List <GroupPoint>();
            unsafe
            {
                #region Начальное позиционирование в изображении
                // позиционируемся в начальной точке
                byte *imagePointer1 = (byte *)bitmapData1.Scan0;
                // и перемещаемся в левый нижний угол изображения
                imagePointer1 += bitmapData1.Stride * posY;
                //задаем направление сканирования изображения
                int dirrection = 1; //1 - to right, 2 - to left

                int deltaX = 0;

                #endregion

                //запуск цикла по изображению
                while (CountPoint > 0)
                {
                    if (dirrection == 1)
                    {
                        deltaX = 0;
                    }
                    else
                    {
                        deltaX = 1;
                    }

                    // получим текущий цвет
                    currColor = 255 - ((imagePointer1[0] + imagePointer1[1] + imagePointer1[2]) / 3);

                    if (isFirstPoint)
                    {
                        GroupPoint tmp = new GroupPoint();
                        tmp.Points.Add(new cncPoint((posX) * sizeOnePoint, posY * sizeOnePoint, 0, 0, 0, false, currColor));
                        pageVectorNOW.Add(tmp.Clone());
                        isFirstPoint = false;
                        lastColor    = currColor;
                    }

                    //тут алгорим работы с данными
                    if (currColor != lastColor)
                    {
                        if (!isFirstPoint)
                        {
                            // в существующий отрезок добавим точку
                            pageVectorNOW[pageVectorNOW.Count - 1].Points.Add(new cncPoint((posX + deltaX) * sizeOnePoint, posY * sizeOnePoint, 0, 0, 0, false, lastColor));

                            // и добавим новый отрезок
                            GroupPoint tmp = new GroupPoint();
                            tmp.Points.Add(new cncPoint((posX + deltaX) * sizeOnePoint, posY * sizeOnePoint, 0, 0, 0, false, currColor));
                            pageVectorNOW.Add(tmp.Clone());
                            lastColor = currColor;
                        }
                    }


                    #region Алгорим вычисления следующей точки в наборе байт изображения
                    //вычисление перехода на следующий блок данных
                    if (dirrection == 1 && posX == bitmapData1.Width - 1)
                    {
                        // в существующий отрезок добавим завершающую точку
                        pageVectorNOW[pageVectorNOW.Count - 1].Points.Add(new cncPoint((posX + 1) * sizeOnePoint, posY * sizeOnePoint, 0, 0, 0, false, lastColor));
                        if (posY != 0)
                        {
                            //TODO: придумать алгоритм
                            //pageVectorNOW[pageVectorNOW.Count - 1].Points.Add(new cncPoint((posX+1) * sizeOnePoint, (posY) * sizeOnePoint, 0, 0, 0, false, 0, 0));
                            //pageVectorNOW[pageVectorNOW.Count - 1].Points.Add(new cncPoint((posX + 1) * sizeOnePoint, (posY - 1) * sizeOnePoint, 0, 0, 0, false, 0, 0));
                            pageVectorNOW[pageVectorNOW.Count - 1].Points.Add(new cncPoint((posX + 1) * sizeOnePoint, (posY - 1) * sizeOnePoint, 0, 0, 0, false, 0, 0));
                        }

                        isFirstPoint = true;

                        dirrection = 2;
                        posY--;

                        posYreal++;



                        imagePointer1 -= bitmapData1.Stride;

                        //imagePointer1 -= (bitmapData1.Stride * posY) + (posX * 3);
                    }
                    else if (dirrection == 2 && posX == 0)
                    {
                        // в существующий отрезок добавим точку
                        pageVectorNOW[pageVectorNOW.Count - 1].Points.Add(new cncPoint(posX * sizeOnePoint, posY * sizeOnePoint, 0, 0, 0, false, lastColor));
                        if (posY != 0)
                        {
                            pageVectorNOW[pageVectorNOW.Count - 1].Points.Add(new cncPoint(posX * sizeOnePoint, (posY - 1) * sizeOnePoint, 0, 0, 0, false, 0, 0));                                  //
                        }
                        isFirstPoint = true;


                        dirrection = 1;
                        posY--;

                        posYreal++;

                        //pageVectorNOW[pageVectorNOW.Count - 1].Points.Add(new cncPoint(posX , posY, 0, 0, 0, false, lastColor));


                        imagePointer1 -= bitmapData1.Stride;

                        //imagePointer1 -= (bitmapData1.Stride * posY);
                    }
                    else if (dirrection == 1)
                    {
                        imagePointer1 += 3;
                        posX++;
                    }
                    else if (dirrection == 2)
                    {
                        imagePointer1 -= 3;
                        posX--;
                    }

                    CountPoint--;
                    #endregion

                    //если это последняя точка то завершим и отрезок
                    if (CountPoint == 0)
                    {
                        if (posY < 0)
                        {
                            posY = 0;
                        }


                        // в существующий отрезок добавим точку
                        //pageVectorNOW[pageVectorNOW.Count - 1].Points.Add(new cncPoint((posX + deltaX)* sizeOnePoint, posY* sizeOnePoint, 0, 0, 0, false, lastColor));
                    }
                } // while (CountPoint > 0)
            }     //unsafe
            pageImageNOW.UnlockBits(bitmapData1);


            //TODO: временный костыль
            //нужно удалить одинаковые точки
            GroupPoint gp = pageVectorNOW[pageVectorNOW.Count - 1];

            List <cncPoint> lpnt = gp.Points;

            if (lpnt.Count > 2)
            {
                cncPoint p1 = lpnt[lpnt.Count - 1];
                cncPoint p2 = lpnt[lpnt.Count - 2];

                if ((p1.X == p2.X && p1.Y == p2.Y && p1.Bright == p2.Bright))
                {
                    lpnt.RemoveAt(lpnt.Count - 1);
                }
            }

            // тут нужно сделать преворот согластно текущй ориентации осей
            pageVectorNOW = VectorProcessing.Rotate(pageVectorNOW);

            //а тут применим график, если есть конечно данные
            List <myPoint> PointsS = new List <myPoint>(); // вычисление значения S
            List <myPoint> PointsF = new List <myPoint>(); // вычисление значения F

            // попытка заполнения

            if (Settings.Default.filter3_mapS != null)
            {
                foreach (string VARIABLE in Settings.Default.filter3_mapS)
                {
                    string[] newSS = VARIABLE.Split(';');
                    if (newSS.Length != 2)
                    {
                        continue;
                    }

                    int p1 = 0;
                    int p2 = 0;

                    int.TryParse(newSS[0].Trim(), out p1);
                    int.TryParse(newSS[1].Trim(), out p2);

                    PointsS.Add(new myPoint(p1, p2));
                }
            }

            if (Settings.Default.filter3_mapF != null)
            {
                foreach (string VARIABLE in Settings.Default.filter3_mapF)
                {
                    string[] newSS = VARIABLE.Split(';');
                    if (newSS.Length != 2)
                    {
                        continue;
                    }

                    int p1 = 0;
                    int p2 = 0;

                    int.TryParse(newSS[0].Trim(), out p1);
                    int.TryParse(newSS[1].Trim(), out p2);

                    PointsF.Add(new myPoint(p1, p2));
                }
            }

            if (PointsS.Count > 0)  //если есть данные вычислим S
            {
                foreach (GroupPoint gg in pageVectorNOW)
                {
                    foreach (cncPoint pp in gg.Points)
                    {
                        pp.Svalue = (int)GetApromixValue(ref PointsS, pp.Bright);
                    }
                }
            }

            if (PointsF.Count > 0)  //если есть данные вычислим F
            {
                foreach (GroupPoint gg in pageVectorNOW)
                {
                    foreach (cncPoint pp in gg.Points)
                    {
                        pp.Fvalue = (int)GetApromixValue(ref PointsF, pp.Bright);
                    }
                }
            }
        }
        // тут зигзагом будем идти по файлу, и получать цвет
        private void GenVar3()
        {
            // работа заточена только под 24-х битный пиксель
            if (pageImageNOW.PixelFormat != PixelFormat.Format24bppRgb)
            {
                //throw new UnsupportedImageFormatException("Оппа! Не поддерживаемый формат изображения!!!");
                MessageBox.Show(
                    "Для генерации данных, требуется изображение имеющее 24 бита на пиксель, а получилось иначе, очень подозрительно....!!");
                return;
            }

            BitmapData bitmapData1 = pageImageNOW.LockBits(new Rectangle(0, 0, pageImageNOW.Width, pageImageNOW.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);

            //значение текущего цвета
            int lastColor = -1; // прошлый цвет
            int currColor = -1; // текущий цвет

            pageVectorNOW = new List <GroupPoint>();



            double sizeOnePoint = (double)numSizePoint.Value;

            bool isFirst = true;
            bool isLast  = false;

            unsafe
            {
                byte *imagePointer1 = (byte *)bitmapData1.Scan0;
                for (int i = 0; i < bitmapData1.Height; i++)
                {
                    //TODO: Доделать............
                    isFirst = true;
                    isLast  = false;

                    GroupPoint tmpGroup = new GroupPoint();

                    for (int j = 0; j < bitmapData1.Width; j++)
                    {
                        // дошли до последней строки в текущей линии
                        if (j == (bitmapData1.Width - 1))
                        {
                            isLast = true;
                        }

                        // получим текущий цвет
                        currColor = 255 - ((imagePointer1[0] + imagePointer1[1] + imagePointer1[2]) / 3);

                        if (isFirst || isLast)
                        {
                            lastColor = currColor;
                            tmpGroup.Points.Add(new cncPoint((j * sizeOnePoint) + (double)deltaX.Value, (i * sizeOnePoint) + (double)deltaY.Value, 0, 0, 0, false, currColor));

                            if (isLast)
                            {
                                pageVectorNOW.Add(tmpGroup.Clone());
                            }

                            isFirst = false;
                        }
                        else
                        {
                            if (lastColor != currColor)
                            {
                                tmpGroup.Points.Add(new cncPoint((j * sizeOnePoint) + (double)deltaX.Value, (i * sizeOnePoint) + (double)deltaY.Value, 0, 0, 0, false, lastColor));
                                lastColor = currColor;
                                tmpGroup.Points.Add(new cncPoint((j * sizeOnePoint) + (double)deltaX.Value, (i * sizeOnePoint) + (double)deltaY.Value, 0, 0, 0, false, currColor));
                            }
                        }

                        imagePointer1 += 3;
                    } //end for j
                    imagePointer1 += bitmapData1.Stride - (bitmapData1.Width * 3);
                }     //end for i
            }         //end unsafe
            pageImageNOW.UnlockBits(bitmapData1);

            //теперь у нечентных линий нужно сменить направление
            bool needRevers = false;

            foreach (GroupPoint gpGroupPoint in pageVectorNOW)
            {
                if (needRevers)
                {
                    gpGroupPoint.Points.Reverse();
                }

                needRevers = !needRevers;
            }

            pageVectorNOW.Reverse();


            ////******************************

            ////направление движения
            ////DirrectionGroupPoint dir = DirrectionGroupPoint.Right;

            //        //if (dir == DirrectionGroupPoint.Left) dir = DirrectionGroupPoint.Right;
            //        //else dir = DirrectionGroupPoint.Left;


            //Bitmap bb = pageImageNOW;
            //BitmapData data = bb.LockBits(new Rectangle(0, 0, bb.Width, bb.Height), ImageLockMode.ReadOnly, bb.PixelFormat);  // make sure you check the pixel format as you will be looking directly at memory

            ////направление движения
            ////DirrectionGroupPoint dir = DirrectionGroupPoint.Right;

            //unsafe
            //{
            //    byte* ptrSrc = (byte*)data.Scan0;

            //    int diff = data.Stride - data.Width;

            //    pageVectorNOW = new List<GroupPoint>();

            //    for (int y = 0; y < data.Height; ++y) //проход по линии
            //    {
            //        List<cncPoint> tmp = new List<cncPoint>();

            //        byte lastValueColor = 0;
            //        bool firstPoint = true;
            //        bool lastPoint = false;


            //        for (int x = 0; x < data.Width; ++x)//проход по точкам
            //        {
            //            lastPoint = (x == data.Width - 1); //будем знать последняя ли это точка линии по которой идем

            //            // windows stores images in BGR pixel order
            //            byte r = ptrSrc[0]; //тут получили нужный цвет

            //            if (firstPoint || lastPoint) //первую и последнюю точку добавим в любом случае
            //            {
            //                firstPoint = false;

            //                cncPoint lk = new cncPoint((x * sizeOnePoint) + (double)deltaX.Value, (y * sizeOnePoint) + (double)deltaY.Value,0,0,0,false,(int)r);

            //                tmp.Add(lk);

            //                lastValueColor = r;
            //            }
            //            else
            //            {
            //                if (lastValueColor != r)
            //                {
            //                    cncPoint lk = new cncPoint((x * sizeOnePoint) + (double)deltaX.Value, (y * sizeOnePoint) + (double)deltaY.Value, 0, 0, 0, false, (int)r);

            //                    tmp.Add(lk);

            //                    lastValueColor = r;
            //                }
            //            }
            //            ptrSrc += 1;
            //        }


            //        // а теперь временный массив скопируем в основной, но с определенным направлением
            //        if (dir == DirrectionGroupPoint.Right)
            //        {
            //            dir = DirrectionGroupPoint.Left;
            //        }
            //        else
            //        {
            //            tmp.Reverse();
            //            dir = DirrectionGroupPoint.Right;
            //        }

            //        pageVectorNOW.Add(new GroupPoint(tmp, false, dir, true));

            //        // ReSharper disable once RedundantAssignment
            //        tmp = new List<cncPoint>();

            //        ptrSrc += diff;
            //    }
            //}

            //bb.UnlockBits(data);

            //// тут нужно сделать преворот согластно текущй ориентации осей
            pageVectorNOW = VectorProcessing.Rotate(pageVectorNOW);

            //а тут применим график
            List <myPoint> Points = new List <myPoint>();


            foreach (string VARIABLE in Settings.Default.filter3_mapS)
            {
                string[] newSS = VARIABLE.Split(';');
                if (newSS.Length != 2)
                {
                    continue;
                }

                int p1 = 0;
                int p2 = 0;

                int.TryParse(newSS[0].Trim(), out p1);
                int.TryParse(newSS[1].Trim(), out p2);

                Points.Add(new myPoint(p1, p2));
            }

            if (Points.Count == 0)
            {
                return;
            }

            //если есть данные вычислим S
            foreach (GroupPoint gg in pageVectorNOW)
            {
                foreach (cncPoint pp in gg.Points)
                {
                    //исходное значение
                    int sourceBright = pp.Bright;

                    //если значение меньше начальной точки
                    if (sourceBright < Points[0].X)
                    {
                        pp.Svalue = Points[0].Y;
                        continue;
                    }

                    if (sourceBright > Points[Points.Count - 1].X)
                    {
                        pp.Svalue = Points[Points.Count - 1].Y;
                        continue;
                    }

                    // а тут пройдемся по диапазону точек
                    int indx = 0;

                    foreach (myPoint Vmp in Points)
                    {
                        if (sourceBright == Vmp.X)
                        {
                            pp.Svalue = Vmp.Y;
                            break;
                        }

                        if (sourceBright < Vmp.X)
                        {
                            //тут нужно рассчитать пропорцию

                            double Bmin = Points[indx - 1].X;
                            double Bmax = Points[indx].X;

                            double Smin = Points[indx - 1].Y;
                            double Smax = Points[indx].Y;

                            double result = 0;

                            if (sourceBright == 0)
                            {
                                pp.Svalue = 0;
                            }
                            else
                            {
                                result    = ((Smax - Smin) / ((Bmax - Bmin) / sourceBright)) + Smin;
                                pp.Svalue = (int)result;
                            }


                            break;
                        }

                        indx++;
                    }



                    //подберем подходящее значение
                    //myPoint pStart = null;
                    //myPoint pStop = null;

                    ////int ind = -1;

                    ////foreach (myPoint VARIABLE in Points)
                    ////{

                    ////    if (sourceValue >= VARIABLE.X)
                    ////    {

                    ////    }
                    ////    else
                    ////    {
                    ////        break;
                    ////    }
                    ////    ind++;
                    ////}

                    ////if (ind == -1) pp.Svalue = 0;

                    ////if (ind > 0)
                    ////{
                    ////    myPoint pstart = Points[ind-1];
                    ////    myPoint pend = Points[ind];

                    ////    pp.Svalue = 100;
                    ////}
                }
            }
        }