//public Square(Engine engine, Bitmap bitmap, int x, int y)
            public Square(Engine engine, BGRA *Data, int Width, int Height, int x, int y)
            {
                m_Engine = engine;

                // 0 1 2
                // 3 4 5
                // 6 7 8

                m_Colors[0] = GetColor(Data, Width, Height, x - 1, y - 1);
                m_Colors[1] = GetColor(Data, Width, Height, x, y - 1);
                m_Colors[2] = GetColor(Data, Width, Height, x + 1, y - 1);
                m_Colors[3] = GetColor(Data, Width, Height, x - 1, y);
                m_Colors[4] = GetColor(Data, Width, Height, x, y);
                m_Colors[5] = GetColor(Data, Width, Height, x + 1, y);
                m_Colors[6] = GetColor(Data, Width, Height, x - 1, y + 1);
                m_Colors[7] = GetColor(Data, Width, Height, x, y + 1);
                m_Colors[8] = GetColor(Data, Width, Height, x + 1, y + 1);

                // 0 1 2
                // 3   4
                // 5 6 7

                m_Shape[1 << 0] = m_Engine.Threshold.Similar(m_Colors[4], m_Colors[0]);
                m_Shape[1 << 1] = m_Engine.Threshold.Similar(m_Colors[4], m_Colors[1]);
                m_Shape[1 << 2] = m_Engine.Threshold.Similar(m_Colors[4], m_Colors[2]);
                m_Shape[1 << 3] = m_Engine.Threshold.Similar(m_Colors[4], m_Colors[3]);
                m_Shape[1 << 4] = m_Engine.Threshold.Similar(m_Colors[4], m_Colors[5]);
                m_Shape[1 << 5] = m_Engine.Threshold.Similar(m_Colors[4], m_Colors[6]);
                m_Shape[1 << 6] = m_Engine.Threshold.Similar(m_Colors[4], m_Colors[7]);
                m_Shape[1 << 7] = m_Engine.Threshold.Similar(m_Colors[4], m_Colors[8]);
            }
Example #2
0
        public unsafe void ToIndexedBgra(Action <int, BGRA> iRgba)
        {
            int width  = (int)(this.Width * this.Scale);
            int height = (int)(this.Height * this.Scale);

            using (Bitmap bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb))
            {
                DrawLines(bitmap, HOT, 0, 0, 0);

                using (var bitmapInRgbFormat = bitmap.Clone(new Rectangle(0, 0, bitmap.Width, bitmap.Height), PixelFormat.Format32bppArgb))
                {
                    BitmapData d = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, bitmapInRgbFormat.PixelFormat);

                    int i = 0;

                    BGRA *ptr     = (BGRA *)d.Scan0.ToPointer();
                    BGRA *lastptr = ptr + (width * height - 1);

                    while (ptr < lastptr)
                    {
                        iRgba(i++, *(ptr++));
                    }

                    bitmap.UnlockBits(d);
                }
            }
        }
Example #3
0
        /// <summary>
        /// Return the next pixel
        /// </summary>
        /// <returns>The next pixel, or null if done</returns>
        public BGRA *GetNextPixel()
        {
            BGRA *pReturnPixel = pCurrentPixel;

            if (xLocation == size.X)
            {
                xLocation = 0;
                yLocation++;
                if (yLocation == size.Y)
                {
                    UnlockBitmap();
                    return(null);
                }
                else
                {
                    pCurrentPixel = this[0, yLocation];
                }
            }
            else
            {
                xLocation++;
                pCurrentPixel++;
            }
            return(pReturnPixel);
        }
Example #4
0
        public static unsafe BGRA* GetRowAddressUnchecked(this System.Drawing.Imaging.BitmapData surf, int y)
        {
            BGRA* dstPtr = (BGRA*)surf.Scan0;

            dstPtr += y * surf.Width;

            return dstPtr;
        }
 private BGRA GetColor(BGRA *Data, int Width, int Height, int x, int y)
 {
     if (x < 0 || y < 0 || x >= Width || y >= Height)
     {
         return(BGRA.FromArgb(0, 0, 0, 0));
     }
     return(Data[y * Width + x]);
 }
Example #6
0
        private static unsafe IImage <T> ReadToArray <T>(System.Drawing.Image img, Func <BGRA, T> convColor, Func <BGRA, T> convBlack, Func <int, int, T[], IImage <T> > generator)
            where T : struct, IEquatable <T>
        {
            Bitmap bitmap = img as Bitmap ?? new Bitmap(img);

            Func <BGRA, T> conv = convColor;

            using (var bitmapInRgbFormat = bitmap.Clone(new Rectangle(0, 0, bitmap.Width, bitmap.Height), PixelFormat.Format32bppArgb))
            {
                BitmapData d = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, bitmapInRgbFormat.PixelFormat);

                var width  = bitmapInRgbFormat.Width;
                var height = bitmapInRgbFormat.Height;
                var data   = new T[width * height];

                int i = 0;

                BGRA *ptr     = (BGRA *)d.Scan0.ToPointer();
                BGRA *lastptr = ptr + (data.Length - 1);

                // We want to use the grayscale transform if possible to ensure most accurate conversion
                // So ensure that the file is color and not greyscale
                if (bitmap.PixelFormat != PixelFormat.Format16bppGrayScale)
                {
                    bool useGrayscale = true;

                    for (BGRA *ptr2 = ptr; ptr2 < lastptr; ptr2++)
                    {
                        if (ptr2->R != ptr2->G || ptr2->G != ptr2->B)
                        {
                            useGrayscale = false;
                            break;
                        }
                    }

                    if (useGrayscale)
                    {
                        // Use Grayscale Algorithm
                        conv = convBlack;
                    }
                }
                else
                {
                    // Use Grayscale Algorithm
                    conv = convBlack;
                }

                while (ptr <= lastptr)
                {
                    data[i++] = conv(*(ptr));
                    ptr++;
                }

                bitmap.UnlockBits(d);

                return(generator(width, height, data));
            }
        }
Example #7
0
 public UnsafeBitmapEnumerator(UnsafeBitmap fastBitmap)
 {
     fastBitmap.LockBitmap();
     locked          = true;
     this.fastBitmap = fastBitmap;
     x             = -1;
     y             = 0;
     pCurrentPixel = fastBitmap[x, y];
 }
Example #8
0
        public static unsafe System.Drawing.Bitmap Load(Stream input)
        {
            DDSLoadInfo info = new DDSLoadInfo();

            LoadDdsFile(input, ref info);

            if (info == default(DDSLoadInfo))
            {
                return null;
            }

            var bitmap = new System.Drawing.Bitmap(info.width, info.height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);

            var rect = new System.Drawing.Rectangle(0, 0, info.width, info.height);

            var data = bitmap.LockBits(rect, System.Drawing.Imaging.ImageLockMode.WriteOnly, bitmap.PixelFormat);

            try
            {
                for (int y = 0; y < info.height; y++)
                {
                    byte* src = (byte*)info.scan0 + (y * info.stride);

                    BGRA* dst = data.GetRowAddressUnchecked(y);

                    for (int x = 0; x < info.width; x++)
                    {
                        dst->R = src[0];
                        dst->G = src[1];
                        dst->B = src[2];
                        dst->A = src[3];

                        src += 4;
                        dst++;
                    }
                }
            }
            finally
            {
                Free(ref info);
            }

            bitmap.UnlockBits(data);

            return bitmap;
        }
        unsafe public byte[] ToBGRA()
        {
            byte[] bgra = new byte[this.Length * 4];

            fixed(BGRA* _dataPtr = &this.data[0])
            fixed (byte* _bgraPtr = &bgra[0])
            {
                BGRA* bgraPtr = (BGRA*)_bgraPtr;
                BGRA* dataPtr = _dataPtr;

                for (int i = 0; i <= this.data.Length; i++)
                {
                    *(bgraPtr++) = *(dataPtr++);
                }
            }

            return bgra;
        }
Example #10
0
        public static PixelData GetPixelData(BGRA *pixel, Types model)
        {
            Color     clr = Color.FromArgb(pixel->red, pixel->green, pixel->blue);
            PixelData pd  = new PixelData(0, 0, 0, clr.Name);

            switch (model)
            {
            case Types.RGB:
                pd.Ch1 = pixel->red;
                pd.Ch2 = pixel->green;
                pd.Ch3 = pixel->blue;
                break;

            default:
                throw new Exception("Konversi tidak terimplementasi");
            }
            pd.Name = clr.Name;
            return(pd);
        }
Example #11
0
 //----------------------------------------------------
 public bool MoveNext()
 {
     x++;
     pCurrentPixel++;
     if (x == fastBitmap.Size.X)
     {
         y++;
         if (y == fastBitmap.Size.Y)
         {
             return(false);
         }
         else
         {
             x             = 0;
             pCurrentPixel = fastBitmap[0, y];
         }
     }
     return(true);
 }
Example #12
0
 public bool MoveNext()
 {
     x++;
     pCurrentPixel++;
     if (x == fastBitmap.Size.X)
     {
         y++;
         if (y == fastBitmap.Size.Y)
         {
             return(false);
         }
         else
         {
             x             = 0;
             pCurrentPixel = fastBitmap[0, y];
             //Debug.WriteLine(String.Format("{0}", pCurrentPixel - fastBitmap[0, 0]));
         }
     }
     return(true);
 }
 public UnsafeBitmapEnumerator(UnsafeBitmap fastBitmap)
 {
     fastBitmap.LockBitmap();
     locked = true;
     this.fastBitmap = fastBitmap;
     x = -1;
     y = 0;
     pCurrentPixel = fastBitmap[x, y];
 }
 /// <summary>
 /// Return the next pixel
 /// </summary>
 /// <returns>The next pixel, or null if done</returns>
 public BGRA* GetNextPixel()
 {
     BGRA* pReturnPixel = pCurrentPixel;
     if (xLocation == size.X)
     {
         xLocation = 0;
         yLocation++;
         if (yLocation == size.Y)
         {
             UnlockBitmap();
             return null;
         }
         else
         {
             pCurrentPixel = this[0, yLocation];
         }
     }
     else
     {
         xLocation++;
         pCurrentPixel++;
     }
     return pReturnPixel;
 }
Example #15
0
 private static float Max(BGRA *pixel)
 {
     return(Max((float)pixel->red, (float)pixel->green, (float)pixel->blue));
 }
Example #16
0
 public static PixelData RGBToHSV(BGRA *pixel)
 {
     return(RGBToHSV(pixel->red, pixel->green, pixel->blue));
 }
 public bool MoveNext()
 {
     x++;
     pCurrentPixel++;
     if (x == fastBitmap.Size.X)
     {
         y++;
         if (y == fastBitmap.Size.Y)
         {
             return false;
         }
         else
         {
             x = 0;
             pCurrentPixel = fastBitmap[0, y];
             //Debug.WriteLine(String.Format("{0}", pCurrentPixel - fastBitmap[0, 0]));
         }
     }
     return true;
 }