Пример #1
0
        /// <summary>
        /// Отримання кольорів пікселів, з використанням вказівників
        /// </summary>
        /// <param name="bitmap">Зображення із якого отримуватиемться RGB кольори</param>
        internal unsafe void GetInfoFromImage2(Bitmap bitmap, PointOb oblast)
        {
            //// Засікаємо час
            //times = new Stopwatch();
            //times.Restart();

            Obrezka.Oblast = oblast;

            int w = Obrezka.Width,
                h = Obrezka.Height;

            // Створюємо/перезаписуємо екземпляр для даних кольорів
            imgPixels2 = new byte[4][, ];
            for (int i = 0; i < 4; i++)
            {
                imgPixels2[i] = new byte[w, h];
            }

            BitmapData BD = bitmap.LockBits(new Rectangle(Obrezka.Oblast.L, Obrezka.Oblast.U,
                                                          w, h), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);

            try
            {
                byte *curpos;

                fixed(byte *a = imgPixels2[0], r = imgPixels2[1],
                      g       = imgPixels2[2], b = imgPixels2[3])
                {
                    byte *_a = a, _r = r, _g = g, _b = b;

                    for (int i = 0; i < h; i++) // висота зображення
                    {
                        curpos = ((byte *)BD.Scan0) + i * BD.Stride;

                        for (int j = 0; j < w; j++)     // ширина зображення
                        {
                            *_b = *(curpos++); _b += h; // компонента синня
                            *_g = *(curpos++); _g += h; // компонента зелена
                            *_r = *(curpos++); _r += h; // компонента червона
                            *_a = *(curpos++); _a += h; // компонента прозорості
                        }

                        {
                            int d = w * h - 1;
                            _b -= d; _g -= d; _r -= d; _a -= d;
                        }
                    }
                }
            }
            finally
            {
                bitmap.UnlockBits(BD);
            }

            //// Зупиняємо час
            //times.Stop();
            //MessageBox.Show("Базовий метод: " + times.ElapsedMilliseconds.ToString() + " мс");

            //imgPixels2 = imgPixels;
        }
Пример #2
0
        /// <summary>
        /// Корегує зображення у відповідності до вибраної області
        /// </summary>
        /// <param name="oblast"></param>
        internal unsafe void SetInfoFromImage(PointOb oblast)
        {
            //// Засікаємо час
            //times = new Stopwatch();
            //times.Restart();
            Obrezka.Oblast = oblast;

            // Створення зображення яке відображатиметься після корекції
            imageCut = new Bitmap(imageSave);

            int w = imageCut.Width,
                h = imageCut.Height;

            //BitmapData BD = imageCut.LockBits(new Rectangle(0, 0, w, h),
            //    ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
            BitmapData BD = imageCut.LockBits(new Rectangle(0, 0, w, h),
                                              ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

            try
            {
                byte *curpos;

                fixed(byte *a = imgPixels[0], r = imgPixels[1],
                      g       = imgPixels[2], b = imgPixels[3])
                {
                    byte *_a = a, _r = r, _g = g, _b = b;

                    for (int i = 0; i < h; i++) // висота зображення
                    {
                        curpos = ((byte *)BD.Scan0) + i * BD.Stride;

                        for (int j = 0; j < w; j++)  // ширина зображення
                        {
                            *(curpos++) = *_b;
                            *(curpos++) = *_g;
                            *(curpos++) = *_r;

                            #region
                            if ((i >= Obrezka.Oblast.U) &&
                                (i <= Obrezka.Oblast.D) &&
                                (j >= Obrezka.Oblast.L) &&
                                (j <= Obrezka.Oblast.R))
                            {
                                *(curpos++) = *_a;
                            }
                            else
                            {
                                *(curpos++) = (byte)Math.Round(*_a / 2.0,
                                                               MidpointRounding.AwayFromZero);
                            }
                            #endregion

                            _b += h; _g += h; _r += h; _a += h;
                        }

                        {
                            int d = w * h - 1;
                            _b -= d; _g -= d; _r -= d; _a -= d;
                        }
                    }
                }
            }
            finally
            {
                imageCut.UnlockBits(BD);
            }

            //// Зупиняємо час
            //times.Stop();
            //MessageBox.Show("Базовий метод: " + times.ElapsedMilliseconds.ToString() + " мс");
        }
Пример #3
0
        /// <summary>
        /// Створює сіре зображення із RGB матриці, в залежності від вибраної кольорової компоненти
        /// </summary>
        /// <param name="mc">Кольорова компонента для сірого зображення</param>
        internal unsafe void SetInfoFromImage(MyColor mc, PointOb oblast)
        {
            //// Засікаємо час
            //times = new Stopwatch();
            //times.Restart();

            Obrezka.Oblast = oblast;

            // Створення зображення яке відображатиметься після корекції
            imageCorect = new Bitmap(imageSave, Obrezka.Width, Obrezka.Height);

            int w = imageCorect.Width,
                h = imageCorect.Height;

            //BitmapData BD = imageCorect.LockBits(new Rectangle(0, 0, w, h),
            //    ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
            BitmapData BD = imageCorect.LockBits(new Rectangle(0, 0, w, h),
                                                 ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

            try
            {
                byte *curpos;

                fixed(byte *a = imgPixels2[0], r = imgPixels2[1],
                      g       = imgPixels2[2], b = imgPixels2[3])
                {
                    byte *_a = a, _r = r, _g = g, _b = b;
                    byte  _t = 0;

                    byte[] _tm;

                    for (int i = 0; i < h; i++) // висота зображення
                    {
                        curpos = ((byte *)BD.Scan0) + i * BD.Stride;

                        for (int j = 0; j < w; j++)  // ширина зображення
                        {
                            // створення списка із 3-х компонент
                            _tm = new byte[3] {
                                *_r, *_g, *_b
                            };

                            switch (mc)
                            {
                                #region Визначення необхідної компоненти і занесення її в зображення
                            case MyColor.red:
                                _t = _tm[0];
                                goto default;

                            case MyColor.green:
                                _t = _tm[1];
                                goto default;

                            case MyColor.blue:
                                _t = _tm[2];
                                goto default;

                            case MyColor.cyan:
                                _t = (byte)(255 - _tm[0]);
                                goto default;

                            case MyColor.magenta:
                                _t = (byte)(255 - _tm[1]);
                                goto default;

                            case MyColor.yellow:
                                _t = (byte)(255 - _tm[2]);
                                goto default;

                            case MyColor.black:
                                _t = (byte)(255 - _tm.Min());
                                goto default;

                            case MyColor.min:
                                _t = _tm.Min();
                                goto default;

                            case MyColor.med:
                                _tm.OrderBy(t => t);
                                _t = _tm[1];
                                goto default;

                            case MyColor.max:
                                _t = _tm.Max();
                                goto default;

                            case MyColor.hm:
                                if (_tm[0] * _tm[1] * _tm[2] != 0)
                                {
                                    _t = (byte)(3 * Math.Round((float)((_tm[0] * _tm[1] * _tm[2]) /
                                                                       (_tm[1] * _tm[2] + _tm[0] * _tm[2] + _tm[0] * _tm[1])),
                                                               MidpointRounding.AwayFromZero));
                                }
                                else
                                {
                                    _t = 0;
                                }
                                goto default;

                            case MyColor.gm:
                                _t = (byte)Math.Round(Math.Pow(_tm[0] * _tm[1] * _tm[2],
                                                               1.0 / 3.0), MidpointRounding.AwayFromZero);
                                goto default;

                            case MyColor.am:
                                _t = (byte)Math.Round((_tm[0] + _tm[1] + _tm[2]) / 3.0,
                                                      MidpointRounding.AwayFromZero);
                                goto default;

                            case MyColor.rms:
                                _t = (byte)Math.Round(Math.Sqrt((_tm[0] * _tm[0] +
                                                                 _tm[1] * _tm[1] + _tm[2] * _tm[2]) / 3.0),
                                                      MidpointRounding.AwayFromZero);
                                goto default;

                            case MyColor.cm:
                                _t = (byte)Math.Round(Math.Pow((_tm[0] * _tm[0] * _tm[0] +
                                                                _tm[1] * _tm[1] * _tm[1] + _tm[2] * _tm[2] * _tm[2]) / 3.0,
                                                               1.0 / 3.0), MidpointRounding.AwayFromZero);
                                goto default;

                            default:
                                *(curpos++) = _t;
                                *(curpos++) = _t;
                                *(curpos++) = _t;
                                *(curpos++) = *_a;
                                break;
                                #endregion
                            }
                            _b += h; _g += h; _r += h; _a += h;
                        }

                        {
                            int d = w * h - 1;
                            _b -= d; _g -= d; _r -= d; _a -= d;
                        }
                    }
                }
            }
            finally
            {
                imageCorect.UnlockBits(BD);
            }

            //// Зупиняємо час
            //times.Stop();
            //MessageBox.Show("Базовий метод: " + times.ElapsedMilliseconds.ToString() + " мс");
        }