public void Apply(BitmapData tileset, BitmapData background) { if (this.chunklist == null) return; foreach (TilesetPatchChunk tilesetPatchChunk in this.chunklist) tilesetPatchChunk.Apply(tileset, background); }
public static void Circle(BitmapData bmpData, int Size, int X, int Y, Color Colour) { CacheCircles(Size); int tempX; int i = 0; for (int tempY = Y - Size; tempY < Y + Size; tempY++) { if (tempY >= 0) { if (tempY >= bmpData.Height) { break; } tempX = X - CircleCache[Size][i]; while (tempX < CircleCache[Size][i] + X) { if (tempX >= 0) { if (tempX >= bmpData.Width) { break; } IntPtr temp = FindPtr(bmpData, tempX, tempY); System.Runtime.InteropServices.Marshal.WriteInt32(temp, Colour.ToArgb()); } tempX++; } } i++; } }
/// <summary> /// Lock bitmap data /// </summary> public void Lock() { try { // Get width and height of bitmap Width = Bitmap.Width; Height = Bitmap.Height; // get total locked pixels count int pixelCount = Width * Height; // Create rectangle to lock Rectangle rect = new Rectangle(0, 0, Width, Height); // get Bitmap bitmap pixel format size Depth = Image.GetPixelFormatSize(Bitmap.PixelFormat); // Check if bpp (Bits Per Pixel) is 8, 24, or 32 if (Depth != 8 && Depth != 24 && Depth != 32) { throw new ArgumentException("Only 8, 24 and 32 bpp images are supported."); } // Lock bitmap and return bitmap data bitmapData = Bitmap.LockBits(rect, ImageLockMode.ReadWrite, Bitmap.PixelFormat); // create byte array to copy pixel values int step = Depth / 8; Pixels = new byte[pixelCount * step]; iptr = bitmapData.Scan0; // Copy data from pointer to array Marshal.Copy(iptr, Pixels, 0, Pixels.Length); } catch (Exception ex) { throw; } }
/// <summary> /// Copy the image buffer back to bitmapdata, then copy it to the original bitmap (image). /// </summary> private void releaseArray() { Marshal.Copy(imageBuffer, 0, bitmapData.Scan0, bitmapData.Stride * bitmap.Height); bitmap.UnlockBits(bitmapData); bitmapData = null; imageBuffer = null; }
public JBitmap(int w, int h, JBitmapPixelFormat _format) { format = _format; bitmap = new Bitmap(w, h, GetPixFormat(format)); bitmapData = bitmap.LockBits(new Rectangle(0, 0, w, h),ImageLockMode.ReadWrite, GetPixFormat(format)); }
/// <summary> /// Initializes a new instance of the <see cref="DesktopSurfaceSource"/> class. /// </summary> /// <param name="bmp">The bitmap from which to read surface data.</param> public DesktopSurfaceSource(Bitmap bmp) { Contract.Require(bmp, nameof(bmp)); this.bmp = bmp; this.bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); }
public static void BltBitmap(IntPtr dstPixels, Size dstSize, int dstX, int dstY, int width, int height, BitmapData srcBD, int srcX, int srcY) { Debug.Assert(srcBD.PixelFormat == PixelFormat.Format32bppArgb); Size srcSize = new Size(srcBD.Width, srcBD.Height); if (!ModifyRectangle(dstSize, ref dstX, ref dstY, ref width, ref height, srcSize, ref srcX, ref srcY)) { return; } unsafe { int dstStride = (dstSize.Width * 4 + 3) / 4 * 4; Debug.Assert(srcBD.Stride % 4 == 0); int* dst = (int*)dstPixels + dstX + (dstY * dstStride / 4); int* src = (int*)srcBD.Scan0 + srcX + (srcY * srcBD.Stride / 4); int paddingDst = dstStride / 4 - width; int paddingSrc = srcBD.Stride / 4 - width; Debug.Assert(0 <= paddingDst); Debug.Assert(0 <= paddingSrc); for (int j = 0; j < height; j++, dst += paddingDst, src += paddingSrc) { for (int i = 0; i < width; i++, dst++, src++) { *dst = *src; } } } }
public static unsafe void GammaCorrect(double gamma, BitmapData imageData) { gamma = Math.Max(0.1, Math.Min(5.0, gamma)); var y = 1.0 / gamma; var table = new byte[0x100]; for (var x = 0; x < 0x100; x++) { table[x] = (byte)Math.Min(0xff, (int)((Math.Pow((x) / 255.0, y) * 255.0) + 0.5)); } var width = imageData.Width; var height = imageData.Height; var num3 = width * ((imageData.PixelFormat == PixelFormat.Format8bppIndexed) ? 1 : 3); var num4 = imageData.Stride - num3; var numPtr = (byte*)imageData.Scan0.ToPointer(); for (var i = 0; i < height; i++) { var num6 = 0; while (num6 < num3) { numPtr[0] = table[numPtr[0]]; num6++; numPtr++; } numPtr += num4; } }
/// <summary> /// Returns try if the given pixel is empty (i.e. alpha is zero) /// </summary> public static unsafe bool EmptyAlphaPixel(BitmapData bitmapData, int px, int py, byte alphaEmptyPixelTolerance) { byte* addr = (byte*)(bitmapData.Scan0) + bitmapData.Stride * py + px * 4; return (*(addr + 3) <= alphaEmptyPixelTolerance); }
public void DrawImg() { imgData = img.LockBits( new Rectangle(0, 0, Width, Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb); }
public Bitmap Apply(Bitmap srcimg, Hashtable positive_table,int tnum) { this.srcimg = ImageUtils.AnyToFormat24bppRgb(srcimg); Height = srcimg.Height; Width = srcimg.Width; this.tnum = tnum; this.positive_table = positive_table; dstimg = new Bitmap(srcimg.Width, srcimg.Height, PixelFormat.Format24bppRgb); srcData = srcimg.LockBits( new Rectangle(0, 0, srcimg.Width, srcimg.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb); dstData = dstimg.LockBits( new Rectangle(0, 0, srcimg.Width, srcimg.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb); Thread[] thread_array = new Thread[tnum]; for (int i = 0; i < tnum; i++) { thread_array[i] = new Thread(new ParameterizedThreadStart(Run)); thread_array[i].Start(i); } for (int i = 0; i < tnum; i++) thread_array[i].Join(); srcimg.UnlockBits(srcData); dstimg.UnlockBits(dstData); return dstimg; }
internal static Bitmap Apply(BitmapData bitmapData1) { Bitmap returnMap = new Bitmap(bitmapData1.Width, bitmapData1.Height, PixelFormat.Format32bppArgb); BitmapData bitmapData2 = returnMap.LockBits(new Rectangle(0, 0, returnMap.Width, returnMap.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); unsafe { byte* imagePointer1 = (byte*)bitmapData1.Scan0; byte* imagePointer2 = (byte*)bitmapData2.Scan0; for (int i = 0; i < bitmapData1.Height; i++) { for (int j = 0; j < bitmapData1.Width; j++) { // Standard Invert algorithm imagePointer2[0] = (byte)(255 - imagePointer1[0]); imagePointer2[1] = (byte)(255 - imagePointer1[1]); imagePointer2[2] = (byte)(255 - imagePointer1[2]); imagePointer2[3] = imagePointer1[3]; //4 bytes per pixel imagePointer1 += 4; imagePointer2 += 4; } //4 bytes per pixel imagePointer1 += bitmapData1.Stride - (bitmapData1.Width * 4); imagePointer2 += bitmapData1.Stride - (bitmapData1.Width * 4); } } returnMap.UnlockBits(bitmapData2); return returnMap; }
// Process the filter private unsafe void ProcessFilter( BitmapData data ) { int width = data.Width; int height = data.Height; int offset = data.Stride - width * 3; // do the job byte * ptr = (byte *) data.Scan0.ToPointer( ); byte t; // for each line for ( int y = 0; y < height; y++ ) { // for each pixel for ( int x = 0; x < width; x++, ptr += 3 ) { // rotate colors of each pixel t = ptr[RGB.R]; ptr[RGB.R] = ptr[RGB.G]; ptr[RGB.G] = ptr[RGB.B]; ptr[RGB.B] = t; } ptr += offset; } }
/// <summary> /// Returns try if the given pixel is empty (i.e. black) /// </summary> public static unsafe bool EmptyPixel(BitmapData bitmapData, int px, int py) { byte* addr = (byte*)(bitmapData.Scan0) + bitmapData.Stride * py + px * 3; return (*addr == 0 && *(addr + 1) == 0 && *(addr + 2) == 0); }
protected virtual void Draw_PANEL_Image(BitmapData data_bac) { foreach (var a in CONTROLS) { a.Value.DrawImage(data_bac); } }
private void InitializeBuffer() { bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.WriteOnly, PixelFormat.Format24bppRgb); imageBuffer = new byte[bitmapData.Stride * bitmap.Height]; }
public static void DrawImageAll(BitmapData data_bac) { for (int i = 0; i < STATIONS.Count; i++) { STATIONS[i].Draw_Image(data_bac); } }
/// <summary> /// Bitmap処理の高速化開始 /// </summary> public void BeginAccess() { // Bitmapに直接アクセスするためのオブジェクト取得(LockBits) _img = _bmp.LockBits(new Rectangle(0, 0, _bmp.Width, _bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format24bppRgb); }
public static void DrawExteriorAll(BitmapData data_bac) { for (int i = 0; i < STATIONS.Count; i++) { STATIONS[i].Draw_Exterior(data_bac); } }
public RawBitmap(Bitmap originBitmap) { OriginBitmap = originBitmap; _bitmapData = OriginBitmap.LockBits(new Rectangle(0, 0, OriginBitmap.Width, OriginBitmap.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb); _begin = (byte*) (void*) _bitmapData.Scan0; }
public static unsafe void drawClearWithBackground(Rectangle srcArea, BitmapData srcData, Rectangle dstArea, BitmapData dstData, BitmapData bgData) { if (srcData == null) return; int stride1 = srcData.Stride; int num1 = (int)srcData.Scan0 + srcArea.X * 4 + srcArea.Y * stride1; if (dstData == null) return; int stride2 = dstData.Stride; int num2 = (int)dstData.Scan0 + dstArea.X * 4 + dstArea.Y * stride2; if (bgData == null) return; int stride3 = bgData.Stride; int num3 = (int)bgData.Scan0 + dstArea.X * 4 + dstArea.Y * stride3; int width = srcArea.Width; int height = srcArea.Height; for (int index1 = 0; index1 < height; ++index1) { int num4 = num1 + index1 * stride1; int num5 = num2 + index1 * stride2; int num6 = num3 + index1 * stride3; for (int index2 = 0; index2 < width; ++index2) { *(PixelData*)num5 = PixelData.overlayPixelData(*(PixelData*)num4, *(PixelData*)num6); num4 += 4; num5 += 4; num6 += 4; } } }
public virtual Bitmap Apply(BitmapData imageData) { if (imageData.PixelFormat != PixelFormat.Format24bppRgb && imageData.PixelFormat != PixelFormat.Format32bppArgb && imageData.PixelFormat != PixelFormat.Format32bppRgb) { throw new ArgumentException(); } int width = imageData.Width; int height = imageData.Height; Bitmap bitmap = new Bitmap( width, height, PixelFormat.Format24bppRgb); BitmapData bitmapdata = bitmap.LockBits( new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb); NativeMethods.memcpy( bitmapdata.Scan0, imageData.Scan0, imageData.Stride * height); ProcessFilter(bitmapdata); bitmap.UnlockBits(bitmapdata); return bitmap; }
public override void DrawImage(BitmapData data_bac) { for(int i=0;i<CANNONS.Length;i++) { CANNONS[i].DrawImage(data_bac); } }
/// <summary> /// Creates a new instance of Smoother /// </summary> public Smoother(BitmapData inBmpData, byte[] inRgbData, IProgressHandler progHandler) { _bmpData = inBmpData; _rgbData = inRgbData; _result = new byte[inRgbData.Length]; pm = new ProgressMeter(progHandler, "Smoothing Image", inBmpData.Height); }
/// <summary> /// Required to use the image after editing. /// </summary> public void Unlock() { System.Runtime.InteropServices.Marshal.Copy(PixelData, 0, BmpData.Scan0, PixelData.Length); BitmapImage.UnlockBits(BmpData); BmpData = null; PixelData = null; }
/// <summary> /// Lock bitmap data /// </summary> public void LockBits() { // Get width and height of bitmap Width = Source.Width; Height = Source.Height; // get total locked pixels count var pixelCount = Width*Height; // Create rectangle to lock var rect = new Rectangle(0, 0, Width, Height); // get source bitmap pixel format size Depth = Image.GetPixelFormatSize(Source.PixelFormat); // Check if bpp (Bits Per Pixel) is 8, 24, or 32 if (Depth != 8 && Depth != 24 && Depth != 32) throw new ArgumentException("Only 8, 24 and 32 bpp images are supported."); // Lock bitmap and return bitmap data _bitmapData = Source.LockBits(rect, ImageLockMode.ReadWrite, Source.PixelFormat); // create byte array to copy pixel values var step = Depth/8; Pixels = new byte[pixelCount*step]; _ptr = _bitmapData.Scan0; // Copy data from pointer to array Marshal.Copy(_ptr, Pixels, 0, Pixels.Length); }
public void Calculate(Bitmap srcimg, int tnum) { if (srcimg.PixelFormat != PixelFormat.Format24bppRgb) { using (Bitmap tmp = new Bitmap(srcimg.Width, srcimg.Height, System.Drawing.Imaging.PixelFormat.Format24bppRgb)) using (Graphics gr = Graphics.FromImage(tmp)) { gr.DrawImage(srcimg, new Rectangle(0, 0, srcimg.Width, srcimg.Height)); srcimg = new Bitmap(tmp); } } Height = srcimg.Height; Width = srcimg.Width; PixelsCount = Height * Width; this.tnum = tnum; srcData = srcimg.LockBits( new Rectangle(0, 0, srcimg.Width, srcimg.Height), ImageLockMode.ReadOnly, srcimg.PixelFormat); Thread[] thread_array = new Thread[tnum]; for (int i = 0; i < tnum; i++) { thread_array[i] = new Thread(new ParameterizedThreadStart(Run)); thread_array[i].Start(i); } for (int i = 0; i < tnum; i++) thread_array[i].Join(); srcimg.UnlockBits(srcData); }
/// <summary> /// Initializes a new instance of the <see cref="ImageBuffer"/> class. /// </summary> public ImageBuffer(Bitmap bitmap, ImageLockMode lockMode) { // locks the image data this.bitmap = bitmap; this.lockMode = lockMode; // gathers the informations Width = bitmap.Width; Height = bitmap.Height; PixelFormat = bitmap.PixelFormat; IsIndexed = PixelFormat.IsIndexed(); BitDepth = PixelFormat.GetBitDepth(); BytesPerPixel = Math.Max(1, BitDepth >> 3); // determines the bounds of an image, and locks the data in a specified mode Rectangle bounds = Rectangle.FromLTRB(0, 0, Width, Height); // locks the bitmap data lock (bitmap) bitmapData = bitmap.LockBits(bounds, lockMode, PixelFormat); // creates internal buffer Stride = bitmapData.Stride < 0 ? -bitmapData.Stride : bitmapData.Stride; Size = Stride*Height; // precalculates the offsets Precalculate(); }
public void LockBits() { try { Width = source.Width; Height = source.Height; int PixelCount = Width * Height; Rectangle rect = new Rectangle(0, 0, Width, Height); Depth = System.Drawing.Bitmap.GetPixelFormatSize(source.PixelFormat); if (Depth != 8 && Depth != 24 && Depth != 32) { throw new ArgumentException("Only 8, 24 and 32 bpp images are supported."); } bitmapData = source.LockBits(rect, ImageLockMode.ReadWrite, source.PixelFormat); int step = Depth / 8; Pixels = new byte[PixelCount * step]; Iptr = bitmapData.Scan0; Marshal.Copy(Iptr, Pixels, 0, Pixels.Length); } catch (Exception ex) { throw ex; } }
public static void DrawImageAll(BitmapData data_bac) { for(int i=0;i<ON_SCREEN.Count;i++) { ON_SCREEN[i].DrawImage(data_bac); } }
/*** * /// <summary> * /// 抠出的数字图像灰度化 * /// </summary> * /// <param name="sender"></param> * /// <param name="e"></param> * private void btnImageGray_Click(object sender, EventArgs e) * { * // 获取图片 * Bitmap bmp = (Bitmap)Image.FromFile(testPath); * // 处理图片 * this.progressBar1.Maximum = bmp.Width * bmp.Height; * * for (int i = 0; i < bmp.Width; i++) * { * for (int j = 0; j < bmp.Height; j++) * { * //获取该点的像素的RGB的颜色 * Color color = bmp.GetPixel(i, j); * //利用公式计算灰度值 * int gray = (int)(color.R * 0.3 + color.G * 0.59 + color.B * 0.11); * Color newColor = Color.FromArgb(gray, gray, gray); * bmp.SetPixel(i, j, newColor); * this.progressBar1.Value++; * } * } * this.picGray.Image = bmp; * * } ****/ #endregion /// <summary> /// 图像二值化 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void btnBitValue_Click(object sender, EventArgs e) { // 文件路径 Bitmap curBitmap = (Bitmap)Image.FromFile(Environment.CurrentDirectory + "//images//gray.jpg"); if (curBitmap != null) { Rectangle rect = new Rectangle(0, 0, curBitmap.Width, curBitmap.Height); System.Drawing.Imaging.BitmapData bmpData = curBitmap.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, curBitmap.PixelFormat); IntPtr ptr = bmpData.Scan0; int bytes = curBitmap.Width * curBitmap.Height * 3; byte[] grayValues = new byte[bytes]; System.Runtime.InteropServices.Marshal.Copy(ptr, grayValues, 0, bytes); byte T = 0; byte[] neighb = new byte[bytes]; byte temp = 0; byte maxGray = 0; byte minGray = 255; int[] countPixel = new int[256]; // 进度条显示 this.progressBar1.Minimum = 0; this.progressBar1.Maximum = grayValues.Length + bytes; this.progressBar1.Value = 0; for (int i = 0; i < grayValues.Length; i++) { temp = grayValues[i]; countPixel[temp]++; if (temp > maxGray) { maxGray = temp; } if (temp < minGray) { minGray = temp; } this.progressBar1.Value++; } double mu1, mu2; int numerator; double sigma; double tempMax = 0; // 大津法二值化图像 double w1 = 0, w2 = 0; double sum = 0; numerator = 0; for (int i = minGray; i <= maxGray; i++) { sum += i * countPixel[i]; } for (int i = minGray; i < maxGray; i++) { w1 += countPixel[i]; numerator += i * countPixel[i]; mu1 = numerator / w1; w2 = grayValues.Length - w1; mu2 = (sum - numerator) / w2; sigma = w1 * w2 * (mu1 - mu2) * (mu1 - mu2); if (sigma > tempMax) { tempMax = sigma; T = Convert.ToByte(i); } } for (int i = 0; i < bytes; i++) { if (grayValues[i] < T) { grayValues[i] = 0; } else { grayValues[i] = 255; } this.progressBar1.Value++; } System.Runtime.InteropServices.Marshal.Copy(grayValues, 0, ptr, bytes); curBitmap.UnlockBits(bmpData); curBitmap.Save(Environment.CurrentDirectory + "//images//bValue.jpg"); this.picBitValue.Image = curBitmap; // 修改界面 btnCut.Enabled = true; pictureBox23.Image = Image.FromFile(@"skin/004.png"); pictureBox27.Image = Image.FromFile(@"skin/004.png"); }// end of if }
private void ReadPixel() { String pathOfBitmapMap = String.Format(@"{0}\{1}", Application.StartupPath, @"Gfx\provinces.bmp"); if (File.Exists(pathOfBitmapMap)) { int idProvince = GetMaxIdProvince(); //------------------------------------------------------------------ StringBuilder colorKey = new StringBuilder(); Dictionary <String, ProvinceDefinitionItem> dictCache = new Dictionary <string, ProvinceDefinitionItem> (); foreach (ProvinceDefinitionItem provinceDefinitionItemCache in m_listProvinceDefinition) { colorKey.Clear(); colorKey.Append(provinceDefinitionItemCache.R); colorKey.Append(provinceDefinitionItemCache.G); colorKey.Append(provinceDefinitionItemCache.B); dictCache.Add(colorKey.ToString(), provinceDefinitionItemCache); } //------------------------------------------------------------------ String colorKeyString = ""; Color pixelColor; m_bitmapMap = new Bitmap(Bitmap.FromFile(pathOfBitmapMap)); m_mapProvinceDefinitionItem = new ProvinceDefinitionItem[m_bitmapMap.Width, m_bitmapMap.Height]; Rectangle rectangle = new Rectangle(0, 0, m_bitmapMap.Width, m_bitmapMap.Height); System.Drawing.Imaging.BitmapData bitmapData = m_bitmapMap.LockBits(rectangle, System.Drawing.Imaging.ImageLockMode.ReadOnly, m_bitmapMap.PixelFormat); int length = bitmapData.Stride * m_bitmapMap.Height; byte[] rawBytes = new byte[length]; System.Runtime.InteropServices.Marshal.Copy(bitmapData.Scan0, rawBytes, 0, length); m_bitmapMap.UnlockBits(bitmapData); ProvinceDefinitionItem provinceDefinitionItem = new ProvinceDefinitionItem(); for (int nXndex = 0; nXndex < m_bitmapMap.Width; nXndex++) { for (int nYndex = 0; nYndex < m_bitmapMap.Height; nYndex++) { pixelColor = Color.FromArgb(rawBytes[nYndex * bitmapData.Stride + nXndex * 4 + 3], rawBytes[nYndex * bitmapData.Stride + nXndex * 4 + 2], rawBytes[nYndex * bitmapData.Stride + nXndex * 4 + 1], rawBytes[nYndex * bitmapData.Stride + nXndex * 4]); if (!((provinceDefinitionItem.R == pixelColor.R) && (provinceDefinitionItem.G == pixelColor.G) && (provinceDefinitionItem.B == pixelColor.B))) { colorKey.Clear(); colorKey.Append(pixelColor.R); colorKey.Append(pixelColor.G); colorKey.Append(pixelColor.B); colorKeyString = colorKey.ToString(); if (dictCache.ContainsKey(colorKeyString)) { provinceDefinitionItem = dictCache[colorKeyString]; } else { String name = String.Format("NewProvince_{0}", idProvince); provinceDefinitionItem = new ProvinceDefinitionItem(++idProvince, pixelColor.R, pixelColor.G, pixelColor.B, name, ""); } } provinceDefinitionItem.ListPixel.Add(new Pixel(nXndex, nYndex)); m_mapProvinceDefinitionItem[nXndex, nYndex] = provinceDefinitionItem; } } m_bitmapMapOverlay = new Bitmap(m_bitmapMap); } }
private void btCaptureBmp_Click(object sender, EventArgs e) { SaveFileDialog saveFileDialog1 = new SaveFileDialog(); saveFileDialog1.FileName = "fingertemplate.bmp"; saveFileDialog1.RestoreDirectory = true; DialogResult result = saveFileDialog1.ShowDialog(); if (result == DialogResult.OK) { string fileName = saveFileDialog1.FileName.ToString(); if (fileName != "" && fileName != null && picFPImg.Image != null) { //http://www.wischik.com/lu/programmer/1bpp.html Bitmap bmp = new Bitmap(picFPImg.Image.Width, picFPImg.Image.Height, System.Drawing.Imaging.PixelFormat.Format24bppRgb); using (Graphics g = Graphics.FromImage(bmp)) { g.DrawImage(picFPImg.Image, 0, 0, bmp.Width, bmp.Height); } Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height); System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat); IntPtr ptr = bmpData.Scan0; int bytes = bmpData.Stride * bmpData.Height; byte[] rgbValues = new byte[bytes]; System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes); Rectangle rect2 = new Rectangle(0, 0, bmp.Width, bmp.Height); Bitmap bit = new Bitmap(bmp.Width, bmp.Height, System.Drawing.Imaging.PixelFormat.Format8bppIndexed); System.Drawing.Imaging.BitmapData bmpData2 = bit.LockBits(rect2, System.Drawing.Imaging.ImageLockMode.ReadWrite, bit.PixelFormat); IntPtr ptr2 = bmpData2.Scan0; int bytes2 = bmpData2.Stride * bmpData2.Height; byte[] rgbValues2 = new byte[bytes2]; System.Runtime.InteropServices.Marshal.Copy(ptr2, rgbValues2, 0, bytes2); double colorTemp = 0; for (int i = 0; i < bmpData.Height; i++) { for (int j = 0; j < bmpData.Width * 3; j += 3) { colorTemp = rgbValues[i * bmpData.Stride + j + 2] * 0.299 + rgbValues[i * bmpData.Stride + j + 1] * 0.578 + rgbValues[i * bmpData.Stride + j] * 0.114; rgbValues2[i * bmpData2.Stride + j / 3] = (byte)colorTemp; } } System.Runtime.InteropServices.Marshal.Copy(rgbValues2, 0, ptr2, bytes2); bmp.UnlockBits(bmpData); ColorPalette tempPalette; { using (Bitmap tempBmp = new Bitmap(1, 1, System.Drawing.Imaging.PixelFormat.Format8bppIndexed)) { tempPalette = tempBmp.Palette; } for (int i = 0; i < 256; i++) { tempPalette.Entries[i] = Color.FromArgb(i, i, i); } bit.Palette = tempPalette; } bit.UnlockBits(bmpData2); bit.Save(fileName, picFPImg.Image.RawFormat); bit.Dispose(); } } }
public static Bitmap equalizing(Bitmap img) { Bitmap bmp = (Bitmap)img.Clone(); Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height); System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat); IntPtr ptr = bmpData.Scan0; int bytes = bmpData.Stride * bmp.Height; byte[] grayValues = new byte[bytes]; int[] R = new int[256]; byte[] N = new byte[256]; byte[] left = new byte[256]; byte[] right = new byte[256]; System.Runtime.InteropServices.Marshal.Copy(ptr, grayValues, 0, bytes); for (int i = 0; i < grayValues.Length; i++) { ++R[grayValues[i]]; } int z = 0; int Hint = 0; int Havg = grayValues.Length / R.Length; for (int i = 0; i < N.Length - 1; i++) { N[i] = 0; } for (int j = 0; j < R.Length; j++) { if (z > 255) { left[j] = 255; } else { left[j] = (byte)z; } Hint += R[j]; while (Hint > Havg) { Hint -= Havg; z++; } if (z > 255) { right[j] = 255; } else { right[j] = (byte)z; } N[j] = (byte)((left[j] + right[j]) / 2); } for (int i = 0; i < grayValues.Length; i++) { if (left[grayValues[i]] == right[grayValues[i]]) { grayValues[i] = left[grayValues[i]]; } else { grayValues[i] = N[grayValues[i]]; } } System.Runtime.InteropServices.Marshal.Copy(grayValues, 0, ptr, bytes); bmp.UnlockBits(bmpData); return(bmp); }
private void btnABC_Click(object sender, RoutedEventArgs e) { abcFile abc; string abcname = ""; Microsoft.Win32.OpenFileDialog ofd = new Microsoft.Win32.OpenFileDialog(); ofd.RestoreDirectory = true; ofd.Title = "Open ABC File"; ofd.Filter = "FontMaker ABC File (*.abc)|*.abc"; if ((bool)ofd.ShowDialog()) { FileStream fs = new FileStream(ofd.FileName, FileMode.Open); BigEndianReader br = new BigEndianReader(fs); br.BaseStream.Position = 0; abc = new abcFile(); abc.Read(br); br.Close(); fs.Close(); abcname = ofd.SafeFileName; } else { return; } if (abc.Height < 0 || abc.Height > 64) { WriteLog("ABC import failed: Height " + abc.Height + " out of range (0-64)."); return; } if (abc.TopPadding < 0 || abc.TopPadding > 64) { WriteLog("ABC import failed: Top padding " + abc.TopPadding + " out of range (0-64)."); return; } if (abc.BottomPadding < 0 || abc.BottomPadding > 64) { WriteLog("ABC import failed: Bottom padding " + abc.BottomPadding + " out of range (0-64)."); return; } if (abc.YAdvance < 0 || abc.YAdvance > 64) { WriteLog("ABC import failed: Indent " + abc.YAdvance + " out of range (0-64)."); return; } ofd = new Microsoft.Win32.OpenFileDialog(); ofd.RestoreDirectory = true; ofd.Title = "Open Font Sheet"; ofd.Filter = "Converted FontMaker Image (*.png)|*.png"; if ((bool)ofd.ShowDialog()) { System.Drawing.Image sheet = System.Drawing.Image.FromFile(ofd.FileName); for (int i = 0; i < abc.GlyphCount; i++) { System.Drawing.Rectangle rect = new System.Drawing.Rectangle(abc.GlyphTable[i].Left, abc.GlyphTable[i].Top, (abc.GlyphTable[i].Right - abc.GlyphTable[i].Left), (abc.GlyphTable[i].Bottom - abc.GlyphTable[i].Top)); if (rect.Left + rect.Width > sheet.Width) { rect.Width = sheet.Width - rect.Left; } if (rect.Top + rect.Height > sheet.Height) { rect.Height = sheet.Height - rect.Top; } //today i learned about empty characters if (rect.Width == 0) { rect.Width = 1; } if (rect.Height == 0) { rect.Height = 1; } Bitmap bm = new Bitmap(sheet); System.Drawing.Imaging.BitmapData bd = bm.LockBits(rect, System.Drawing.Imaging.ImageLockMode.WriteOnly, bm.PixelFormat); var sauce = BitmapSource.Create(bd.Width, bd.Height, 96, 96, System.Windows.Media.PixelFormats.Bgra32, null, bd.Scan0, bd.Stride * bd.Height, bd.Stride); MemoryStream ms = new MemoryStream(); var encoder = new System.Windows.Media.Imaging.PngBitmapEncoder(); encoder.Frames.Add(System.Windows.Media.Imaging.BitmapFrame.Create(sauce)); encoder.Save(ms); ms.Flush(); var dispwidth = abc.GlyphTable[i].Width; if (abc.CharCodes[i] == 0x20) { var periodindex = package.Fonts[fontslist.SelectedIndex].FindCharacter(0x2C); if (periodindex != -1) { dispwidth = package.Fonts[fontslist.SelectedIndex].Characters[periodindex].Data.dispWidth; } else { dispwidth = 4; } } package.AddCustomCharacter(abc.CharCodes[i], fontslist.SelectedIndex, System.Drawing.Image.FromStream(ms), CharTint.None, true, dispwidth); ms.Close(); bm.Dispose(); } //for (int i = 0; i < package.Fonts[fontslist.SelectedIndex].Characters.Count; i++) //{ // package.Fonts[fontslist.SelectedIndex].Characters[i].Data.dispHeight = (ushort)abc.YAdvance; //} // //UpdateFontInfo((short)abc.Height, (short)abc.TopPadding, (short)abc.BottomPadding, 0); UpdateFontDisplay(); WriteLog("Characters successfully imported from abc file \"" + abcname + "\"."); } }
public void TestGDITextToTexture2D() { var bmp = new Bitmap(100, 100, PixelFormat.Format32bppArgb); var canvasSize = new Point(bmp.Width, bmp.Height); var c = Color.Red; var textCoordinate = new Point(0, 0); //Then create a graphics object to be able to write in the bmp image var g = System.Drawing.Graphics.FromImage(bmp); //g.MeasureString(text, font, canvasSize, sf); g.PageUnit = GraphicsUnit.Pixel; g.Clear(Color.Transparent); g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias; //then create a brush (with a color) and write the text in the bmp file specifying text coordinates and alignment Brush brush = new SolidBrush(c); g.DrawString("Hello Wizard", new Font("Verdana", 10), brush, textCoordinate.X, textCoordinate.Y, StringFormat.GenericDefault); g.Flush(); // Lock the bitmap's bits. Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height); System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat); // Get the address of the first line. IntPtr ptr = bmpData.Scan0; // Declare an array to hold the bytes of the bitmap. int bytes = Math.Abs(bmpData.Stride) * bmp.Height; byte[] rgbValues = new byte[bytes]; // Copy the RGB values into the array. System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes); // Unlock the bits. bmp.UnlockBits(bmpData); var game = new DX11Game(); game.InitDirectX(); var tex = new Texture2D(game.Device, new Texture2DDescription { ArraySize = 1, MipLevels = 1, Format = Format.B8G8R8A8_UNorm, Usage = ResourceUsage.Dynamic, CpuAccessFlags = CpuAccessFlags.Write, Width = bmp.Width, Height = bmp.Height, SampleDescription = new SampleDescription(1, 0), BindFlags = BindFlags.ShaderResource }); var box = game.Device.ImmediateContext.MapSubresource(tex, 0, 0, MapMode.WriteDiscard, SlimDX.Direct3D11.MapFlags.None); for (int iRow = 0; iRow < bmp.Height; iRow++) { box.Data.Seek(iRow * box.RowPitch, SeekOrigin.Begin); box.Data.Write(rgbValues, iRow * 4 * bmp.Width, bmp.Width * 4); } game.Device.ImmediateContext.UnmapSubresource(tex, 0); var view = new ShaderResourceView(game.Device, tex); game.GameLoopEvent += delegate { game.TextureRenderer.Draw(view, Vector2.Zero, new Vector2(bmp.Width, bmp.Height)); }; game.Run(); }
public int CompareGrpah(string CmpGraphFile, ref string SysMsg, ref List <string> lCmpInfo) { int ret = SystemInfo.ERROR_RESULT_OK; string AddrTmp = null; SL_IO_Util FileVerfiy = new SL_IO_Util(); if (!FileVerfiy.isFileExist(ImgPath)) { return(SystemInfo.ERROR_CMP_FILENOTEXIST); } if (!FileVerfiy.isFileExist(CmpGraphFile)) { return(SystemInfo.ERROR_CMP_FILENOTEXIST); } Bitmap DefaultBmp = new Bitmap(ImgPath); Bitmap CmpBmp = new Bitmap(CmpGraphFile); Rectangle DefaultRect = new Rectangle(0, 0, DefaultBmp.Width, DefaultBmp.Height); Rectangle CmpRect = new Rectangle(0, 0, CmpBmp.Width, CmpBmp.Height); System.Drawing.Imaging.BitmapData DefaultBmpData = DefaultBmp.LockBits(DefaultRect, System.Drawing.Imaging.ImageLockMode.ReadWrite, DefaultBmp.PixelFormat); System.Drawing.Imaging.BitmapData CmpBmpData = CmpBmp.LockBits(CmpRect, System.Drawing.Imaging.ImageLockMode.ReadWrite, CmpBmp.PixelFormat); // Get the address of the first line. IntPtr DefualtPtr = DefaultBmpData.Scan0; IntPtr CmpPtr = CmpBmpData.Scan0; // Declare an array to hold the bytes of the bitmap. int DefaultBytes = Math.Abs(DefaultBmpData.Stride) * DefaultBmp.Height; int CmpBytes = Math.Abs(CmpBmpData.Stride) * CmpBmpData.Height; int ResultBytes = Math.Abs(DefaultBmpData.Stride) * DefaultBmpData.Height; byte[] DrgbValues = new byte[DefaultBytes]; byte[] CrgbValues = new byte[CmpBytes]; byte[] RrgbValues = new byte[ResultBytes]; // Copy the RGB values into the array. System.Runtime.InteropServices.Marshal.Copy(DefualtPtr, DrgbValues, 0, DefaultBytes); System.Runtime.InteropServices.Marshal.Copy(CmpPtr, CrgbValues, 0, CmpBytes); // Set every third value to 255. A 24bpp bitmap will look red. for (int Counter = 0; Counter < DrgbValues.Length; Counter += 3) { if (DrgbValues[Counter] == CrgbValues[Counter] && DrgbValues[Counter + 1] == CrgbValues[Counter + 1] && DrgbValues[Counter + 2] == CrgbValues[Counter + 2]) { RrgbValues[Counter] = RrgbValues[Counter + 1] = RrgbValues[Counter + 2] = 255; } else { RrgbValues[Counter + 2] = 255; RrgbValues[Counter + 1] = RrgbValues[Counter] = 0; AddrTmp = CountLocation(DefaultBmp.Width, DefaultBmp.Height, Counter); ShowCmpMsg(ref lCmpInfo, AddrTmp, DrgbValues[Counter + 2], DrgbValues[Counter + 1], DrgbValues[Counter], CrgbValues[Counter + 2], CrgbValues[Counter + 1], CrgbValues[Counter]); ret = SystemInfo.ERROR_CMP_ERROR; } } // Copy the RGB values back to the bitmap System.Runtime.InteropServices.Marshal.Copy(DrgbValues, 0, DefualtPtr, DefaultBytes); System.Runtime.InteropServices.Marshal.Copy(CrgbValues, 0, CmpPtr, CmpBytes); // Unlock the bits. DefaultBmp.UnlockBits(DefaultBmpData); CmpBmp.UnlockBits(CmpBmpData); ResultBmp = CreateBmp(RrgbValues, DefaultBmp.Width, DefaultBmp.Height); return(ret); }
private void Map_Robot_Image_Processing2(ref Bitmap bmSource, int Width, int Height, byte[] sourcemapvalue, string strfiltername) { try { // // 여기서 부터 Picture Box의 이미지를 복사해 오는 부분입니다 // Rectangle rect = new Rectangle(0, 0, bmSource.Width, bmSource.Height); System.Drawing.Imaging.BitmapData bmpData = bmSource.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmSource.PixelFormat); IntPtr ptr = bmpData.Scan0; byte[] rgbValues; if (bmSource.PixelFormat == PixelFormat.Format32bppArgb || bmSource.PixelFormat == PixelFormat.Format32bppRgb) { rgbValues = new byte[Width * Height * 4]; } else { rgbValues = new byte[Width * Height]; } if (bmSource.PixelFormat == PixelFormat.Format32bppArgb || bmSource.PixelFormat == PixelFormat.Format32bppRgb) { var k = 0; for (var y = 0; y < Height; y++) { for (var x = 0; x < Width; x++) { byte btemp = sourcemapvalue[y * Width + x]; if (strfiltername == "gray" || strfiltername == "cost" || strfiltername == "globalcost") { //if (btemp == 0) btemp = 0xff; //else if (btemp == 0xff) btemp = 0xf0; } else { if (btemp == 0) { btemp = 0xff; } } #region gray filter 그레이는 r,g,b가 동일 값으로 들어감 if (strfiltername == "gray" || strfiltername == "cost" || strfiltername == "globalcost") { rgbValues[k] = btemp; rgbValues[k + 1] = btemp; rgbValues[k + 2] = btemp; } #endregion k += 4; } } } else { for (int i = 0; i < Width * Height; i++) { rgbValues[i] = sourcemapvalue[i]; } } // // 여기까지가 Marshal Copy로 rgbValues 버퍼로 영상을 Copy해 오는 부분입니다. // // // 여기서부터 2차원 배열로 1차원 영상을 옮기는 부분입니다 // double[,] Source = new double[Width, Height]; double[,] Target = new double[Width, Height]; int XPos, YPos = 0; if (bmSource.PixelFormat == PixelFormat.Format32bppArgb || bmSource.PixelFormat == PixelFormat.Format32bppRgb) { for (int nH = 0; nH < Height; nH++) { XPos = 0; if (strfiltername == "gray") { XPos = 0; //gray xpos } for (int nW = 0; nW < Width; nW++) { Source[nW, nH] = rgbValues[XPos + YPos]; Target[nW, nH] = rgbValues[XPos + YPos]; XPos += 4; } YPos += Width * 4; } } else { for (int nH = 0; nH < Height; nH++) { XPos = 0; for (int nW = 0; nW < Width; nW++) { Source[nW, nH] = rgbValues[XPos + YPos]; Target[nW, nH] = rgbValues[XPos + YPos]; XPos++; } YPos += Width; } } // // 여기까지는 2차원 배열로 영상을 복사하는 부분입니다. // //좌우반전// int nconvert = 0; //상하반전 nconvert = 0; double[,] bconvertTarget = new double[Width, Height]; for (int nh = 0; nh < Height; nh++) { nconvert = 0; for (int nw = 0; nw < Width; nw++) { bconvertTarget[nw, Height - nh - 1] = Target[nw, nh]; //nconvert++; } } // // 여기서 부터는 2차원 배열을 다시 1차원 버터로 옮기는 부분입니다 // if (bmSource.PixelFormat == PixelFormat.Format32bppArgb || bmSource.PixelFormat == PixelFormat.Format32bppRgb) { rgbValues = new byte[Width * Height * 4]; } else { rgbValues = new byte[Width * Height]; } YPos = 0; if (bmSource.PixelFormat == PixelFormat.Format32bppArgb || bmSource.PixelFormat == PixelFormat.Format32bppRgb) { for (int nH = 0; nH < Height; nH++) { XPos = 0; for (int nW = 0; nW < Width; nW++) { #region gray filter 그레이는 r,g,b가 동일 값으로 들어감 if (strfiltername == "gray") { bconvertTarget[nW, nH] = (byte)(255 - (255 * bconvertTarget[nW, nH]) / 100); rgbValues[XPos + YPos] = (byte)bconvertTarget[nW, nH]; rgbValues[XPos + YPos + 1] = (byte)bconvertTarget[nW, nH]; rgbValues[XPos + YPos + 2] = (byte)bconvertTarget[nW, nH]; } #endregion if (strfiltername == "globalcost") { bconvertTarget[nW, nH] = (byte)(255 - (255 * bconvertTarget[nW, nH]) / 100); rgbValues[XPos + YPos] = (byte)bconvertTarget[nW, nH]; rgbValues[XPos + YPos + 1] = (byte)bconvertTarget[nW, nH]; rgbValues[XPos + YPos + 2] = (byte)bconvertTarget[nW, nH]; } #region cost map filter if (strfiltername == "cost") { //cost map 색상 테스트 if (bconvertTarget[nW, nH] < 36) { rgbValues[XPos + YPos] = 0xff; rgbValues[XPos + YPos + 1] = 0xff; rgbValues[XPos + YPos + 2] = 0xff; rgbValues[XPos + YPos + 3] = 255; } else if (bconvertTarget[nW, nH] == 100) // lethal obstacle values (100) in purple { rgbValues[XPos + YPos] = 255; rgbValues[XPos + YPos + 1] = 0; rgbValues[XPos + YPos + 2] = 255; rgbValues[XPos + YPos + 3] = 255; } else if (bconvertTarget[nW, nH] > 101 && bconvertTarget[nW, nH] < 128) // illegal positive values in green { rgbValues[XPos + YPos] = 0; rgbValues[XPos + YPos + 1] = 255; rgbValues[XPos + YPos + 2] = 0; rgbValues[XPos + YPos + 3] = 255; } else if (bconvertTarget[nW, nH] > 155 && bconvertTarget[nW, nH] < 255) // illegal negative (char) values in shades of red/yellow { rgbValues[XPos + YPos] = 255; rgbValues[XPos + YPos + 1] = (byte)((255 * (bconvertTarget[nW, nH] - 128)) / (254 - 128)); rgbValues[XPos + YPos + 2] = 0; rgbValues[XPos + YPos + 3] = 255; } else { rgbValues[XPos + YPos] = 255; rgbValues[XPos + YPos + 1] = 255; rgbValues[XPos + YPos + 2] = (byte)bconvertTarget[nW, nH]; rgbValues[XPos + YPos + 3] = 255; } } #endregion XPos += 4; } YPos += Width * 4; } } else { for (int nH = 0; nH < Height; nH++) { XPos = 0; for (int nW = 0; nW < Width; nW++) { rgbValues[XPos + YPos] = (byte)bconvertTarget[nW, nH]; XPos++; } YPos += Width; } } // // 다시 Marshal Copy로 Picture Box로 옮기는 부분입니다 // if (bmSource.PixelFormat == PixelFormat.Format32bppArgb || bmSource.PixelFormat == PixelFormat.Format32bppRgb) { System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, Width * Height * 4); } else { System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, Width * Height); } bmSource.UnlockBits(bmpData); //System.Drawing.Rectangle cropArea = new System.Drawing.Rectangle(6, 6, Width - 12, Height - 12); System.Drawing.Rectangle cropArea = new System.Drawing.Rectangle(0, 0, Width, Height); Bitmap bmpTemp = bmSource.Clone(cropArea, bmSource.PixelFormat); bmSource.Dispose(); bmSource = null; bmSource = (Bitmap)(bmpTemp.Clone()); } catch (Exception ex) { Console.Out.WriteLine("Map_Robot_Image_Processing2 err :={0}", ex.Message.ToString()); } }
/// <summary> /// Convert raw data to bitmap /// </summary> /// <param name="scan0">The pointer to the raw data</param> /// <param name="step">The step</param> /// <param name="size">The size of the image</param> /// <param name="srcColorType">The source image color type</param> /// <param name="numberOfChannels">The number of channels</param> /// <param name="srcDepthType">The source image depth type</param> /// <param name="tryDataSharing">Try to create Bitmap that shares the data with the image</param> /// <returns>The Bitmap</returns> public static Bitmap RawDataToBitmap(IntPtr scan0, int step, Size size, Type srcColorType, int numberOfChannels, Type srcDepthType, bool tryDataSharing = false) { if (tryDataSharing) { if (srcColorType == typeof(Gray) && srcDepthType == typeof(Byte)) { //Grayscale of Bytes Bitmap bmpGray = new Bitmap( size.Width, size.Height, step, System.Drawing.Imaging.PixelFormat.Format8bppIndexed, scan0 ); bmpGray.Palette = GrayscalePalette; return(bmpGray); } // Mono in Linux doesn't support scan0 constructure with Format24bppRgb, use ToBitmap instead // See https://bugzilla.novell.com/show_bug.cgi?id=363431 // TODO: check mono buzilla Bug 363431 to see when it will be fixed else if ( Emgu.Util.Platform.OperationSystem == Emgu.Util.TypeEnum.OS.Windows && Emgu.Util.Platform.ClrType == Emgu.Util.TypeEnum.ClrType.DotNet && srcColorType == typeof(Bgr) && srcDepthType == typeof(Byte) && (step & 3) == 0) { //Bgr byte return(new Bitmap( size.Width, size.Height, step, System.Drawing.Imaging.PixelFormat.Format24bppRgb, scan0)); } else if (srcColorType == typeof(Bgra) && srcDepthType == typeof(Byte)) { //Bgra byte return(new Bitmap( size.Width, size.Height, step, System.Drawing.Imaging.PixelFormat.Format32bppArgb, scan0)); } //PixelFormat.Format16bppGrayScale is not supported in .NET //else if (typeof(TColor) == typeof(Gray) && typeof(TDepth) == typeof(UInt16)) //{ // return new Bitmap( // size.width, // size.height, // step, // PixelFormat.Format16bppGrayScale; // scan0); //} } System.Drawing.Imaging.PixelFormat format; //= System.Drawing.Imaging.PixelFormat.Undefined; if (srcColorType == typeof(Gray)) // if this is a gray scale image { format = System.Drawing.Imaging.PixelFormat.Format8bppIndexed; } else if (srcColorType == typeof(Bgra)) //if this is Bgra image { format = System.Drawing.Imaging.PixelFormat.Format32bppArgb; } else if (srcColorType == typeof(Bgr)) //if this is a Bgr Byte image { format = System.Drawing.Imaging.PixelFormat.Format24bppRgb; } else { using (Mat m = new Mat(size.Height, size.Width, CvInvoke.GetDepthType(srcDepthType), numberOfChannels, scan0, step)) using (Mat m2 = new Mat()) { CvInvoke.CvtColor(m, m2, srcColorType, typeof(Bgr)); return(RawDataToBitmap(m2.DataPointer, m2.Step, m2.Size, typeof(Bgr), 3, srcDepthType, false)); } } Bitmap bmp = new Bitmap(size.Width, size.Height, format); System.Drawing.Imaging.BitmapData data = bmp.LockBits( new Rectangle(Point.Empty, size), System.Drawing.Imaging.ImageLockMode.WriteOnly, format); using (Mat bmpMat = new Mat(size.Height, size.Width, CvEnum.DepthType.Cv8U, numberOfChannels, data.Scan0, data.Stride)) using (Mat dataMat = new Mat(size.Height, size.Width, CvInvoke.GetDepthType(srcDepthType), numberOfChannels, scan0, step)) { if (srcDepthType == typeof(Byte)) { dataMat.CopyTo(bmpMat); } else { double scale = 1.0, shift = 0.0; RangeF range = dataMat.GetValueRange(); if (range.Max > 255.0 || range.Min < 0) { scale = range.Max.Equals(range.Min) ? 0.0 : 255.0 / (range.Max - range.Min); shift = scale.Equals(0) ? range.Min : -range.Min * scale; } CvInvoke.ConvertScaleAbs(dataMat, bmpMat, scale, shift); } } bmp.UnlockBits(data); if (format == System.Drawing.Imaging.PixelFormat.Format8bppIndexed) { bmp.Palette = GrayscalePalette; } return(bmp); }
private void thread_DoWork(CancellationToken token) { MFFactoryClass _factory = new MFFactoryClass(); while (!token.IsCancellationRequested) { if (decode) { MFFrame frame = null; string path = String.Format(@"\\MLDiskStation\MLFiles\Trash\Roman\NetTestFiles\LG_jazz\LG_jazz\LG_jazz{0:d7}.jpg", index); Debug.WriteLine("Picture:" + index.ToString()); index = ++index == 291 ? 0 : index; //291 is count of pictures in image sequences { Bitmap bmp = (Bitmap)System.Drawing.Image.FromFile(path); Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height); System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly, PixelFormat.Format32bppPArgb); M_AV_PROPS avProps = new M_AV_PROPS(); avProps.vidProps.eVideoFormat = eMVideoFormat.eMVF_HD1080_30p; avProps.vidProps.fccType = eMFCC.eMFCC_RGB32; avProps.vidProps.nWidth = bmp.Width; avProps.vidProps.nHeight = -1 * bmp.Height; // Negative height for top-bottom RGB images (if positive->bottom-top) avProps.vidProps.nRowBytes = bmpData.Stride; // distance between lines _factory.MFFrameCreateFromMem(ref avProps, bmpData.Scan0.ToInt64(), 0, 0, out frame, ""); bmp.UnlockBits(bmpData); bmp.Dispose(); } M_AV_PROPS props; int samples; frame.MFAVPropsGet(out props, out samples); props.vidProps.eVideoFormat = eMVideoFormat.eMVF_HD1080_30p; props.vidProps.dblRate = 30.0; props.vidProps.nAspectX = 16; props.vidProps.nAspectY = 9; MFFrame frameConvert; int nRest = 0; frame.MFConvert(ref props, out frameConvert, out nRest, "", ""); m_objPreview.ReceiverFramePut(frameConvert, 0, ""); m_objWriter.ReceiverFramePut(frameConvert, -1, ""); if (stopWr) { m_objWriter.WriterClose(0); } Marshal.ReleaseComObject(frameConvert); Marshal.ReleaseComObject(frame); GC.Collect(); } } }
//边缘检测算法 private static Bitmap smoothed(Bitmap a) { int w = a.Width; int h = a.Height; try { Bitmap dstBitmap = new Bitmap(w, h, System.Drawing.Imaging.PixelFormat.Format24bppRgb); System.Drawing.Imaging.BitmapData srcData = a.LockBits(new Rectangle (0, 0, w, h), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb); BitmapData dstData = dstBitmap.LockBits(new Rectangle (0, 0, w, h), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format24bppRgb); unsafe { byte *pIn = (byte *)srcData.Scan0.ToPointer(); byte *pOut = (byte *)dstData.Scan0.ToPointer(); byte *p; int stride = srcData.Stride; for (int y = 0; y < h; y++) { for (int x = 0; x < w; x++) { //边缘八个点像素不变 if (x == 0 || x == w - 1 || y == 0 || y == h - 1) { pOut[0] = pIn[0]; pOut[1] = pIn[1]; pOut[2] = pIn[2]; } else { int r0, r1, r2, r3, r4, r5, r6, r7, r8; int g1, g2, g3, g4, g5, g6, g7, g8, g0; int b1, b2, b3, b4, b5, b6, b7, b8, b0; double vR, vG, vB; //左上 p = pIn - stride - 3; r1 = p[2]; g1 = p[1]; b1 = p[0]; //正上 p = pIn - stride; r2 = p[2]; g2 = p[1]; b2 = p[0]; //右上 p = pIn - stride + 3; r3 = p[2]; g3 = p[1]; b3 = p[0]; //左 p = pIn - 3; r4 = p[2]; g4 = p[1]; b4 = p[0]; //右 p = pIn + 3; r5 = p[2]; g5 = p[1]; b5 = p[0]; //左下 p = pIn + stride - 3; r6 = p[2]; g6 = p[1]; b6 = p[0]; //正下 p = pIn + stride; r7 = p[2]; g7 = p[1]; b7 = p[0]; // 右下 p = pIn + stride + 3; r8 = p[2]; g8 = p[1]; b8 = p[0]; //中心点 p = pIn; r0 = p[2]; g0 = p[1]; b0 = p[0]; //使用模板 vR = (double)(Math.Abs(r3 + r5 + r8 - r1 - r4 - r6) + Math.Abs(r1 + r2 + r3 - r6 - r7 - r8)); vG = (double)(Math.Abs(g3 + g5 + g8 - g1 - g4 - g6) + Math.Abs(g1 + g2 + g3 - g6 - g7 - g8)); vB = (double)(Math.Abs(b3 + b5 + b8 - b1 - b4 - b6) + Math.Abs(b1 + b2 + b3 - b6 - b7 - b8)); if (vR > 0) { vR = Math.Min(255, vR); } else { vR = Math.Max(0, vR); } if (vG > 0) { vG = Math.Min(255, vG); } else { vG = Math.Max(0, vG); } if (vB > 0) { vB = Math.Min(255, vB); } else { vB = Math.Max(0, vB); } pOut[0] = (byte)vB; pOut[1] = (byte)vG; pOut[2] = (byte)vR; } pIn += 3; pOut += 3; } pIn += srcData.Stride - w * 3; pOut += srcData.Stride - w * 3; } } a.UnlockBits(srcData); dstBitmap.UnlockBits(dstData); return(dstBitmap); } catch { return(null); } }
public void TestCreateTexture2DFromBitmap() { Bitmap bitmap = createBitmap(); var bmp = bitmap; // Lock the bitmap's bits. Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height); System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat); // Get the address of the first line. IntPtr ptr = bmpData.Scan0; // Declare an array to hold the bytes of the bitmap. int bytes = Math.Abs(bmpData.Stride) * bmp.Height; byte[] rgbValues = new byte[bytes]; // Copy the RGB values into the array. System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes); // Unlock the bits. bmp.UnlockBits(bmpData); var game = new DX11Game(); game.InitDirectX(); var tex = new Texture2D(game.Device, new Texture2DDescription { ArraySize = 1, MipLevels = 1, Format = Format.R8G8B8A8_UNorm, Usage = ResourceUsage.Dynamic, CpuAccessFlags = CpuAccessFlags.Write, Width = bmp.Width, Height = bmp.Height, SampleDescription = new SampleDescription(1, 0), BindFlags = BindFlags.ShaderResource }); var box = game.Device.ImmediateContext.MapSubresource(tex, 0, 0, MapMode.WriteDiscard, SlimDX.Direct3D11.MapFlags.None); for (int iRow = 0; iRow < bmp.Height; iRow++) { box.Data.Seek(iRow * box.RowPitch, SeekOrigin.Begin); box.Data.Write(rgbValues, iRow * 4 * bmp.Width, bmp.Width * 4); } game.Device.ImmediateContext.UnmapSubresource(tex, 0); var view = new ShaderResourceView(game.Device, tex); game.GameLoopEvent += delegate { game.TextureRenderer.Draw(view, Vector2.Zero, new Vector2(100, 100)); }; game.Run(); }
public void TrimSpace(Document doc, int i) { // Render the page to image with 72 DPI PngDevice device = new PngDevice(new Resolution(72)); using (MemoryStream imageStr = new MemoryStream()) { device.Process(doc.Pages[i], imageStr); Bitmap bmp = (Bitmap)Bitmap.FromStream(imageStr); System.Drawing.Imaging.BitmapData imageBitmapData = null; // Determine white areas try { imageBitmapData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppRgb); Aspose.Pdf.Rectangle prevCropBox = doc.Pages[i].CropBox; int toHeight = bmp.Height; int toWidth = bmp.Width; int?leftNonWhite = null; int?rightNonWhite = null; int?topNonWhite = null; int?bottomNonWhite = null; for (int y = 0; y < toHeight; y++) { byte[] imageRowBytes = new byte[imageBitmapData.Stride]; // Copy the row data to byte array if (IntPtr.Size == 4) { System.Runtime.InteropServices.Marshal.Copy(new IntPtr(imageBitmapData.Scan0.ToInt32() + y * imageBitmapData.Stride), imageRowBytes, 0, imageBitmapData.Stride); } else { System.Runtime.InteropServices.Marshal.Copy(new IntPtr(imageBitmapData.Scan0.ToInt64() + y * imageBitmapData.Stride), imageRowBytes, 0, imageBitmapData.Stride); } int?leftNonWhite_row = null; int?rightNonWhite_row = null; for (int x = 0; x < toWidth; x++) { if (imageRowBytes[x * 4] != 255 || imageRowBytes[x * 4 + 1] != 255 || imageRowBytes[x * 4 + 2] != 255) { if (leftNonWhite_row == null) { leftNonWhite_row = x; } rightNonWhite_row = x; } } if (leftNonWhite_row != null || rightNonWhite_row != null) { if (topNonWhite == null) { topNonWhite = y; } bottomNonWhite = y; } if (leftNonWhite_row != null && (leftNonWhite == null || leftNonWhite > leftNonWhite_row)) { leftNonWhite = leftNonWhite_row; } if (rightNonWhite_row != null && (rightNonWhite == null || rightNonWhite < rightNonWhite_row)) { rightNonWhite = rightNonWhite_row; } } leftNonWhite = leftNonWhite ?? 0; rightNonWhite = rightNonWhite ?? toWidth; topNonWhite = topNonWhite ?? 0; bottomNonWhite = bottomNonWhite ?? toHeight; // Set crop box with correction to previous crop box doc.Pages[i].CropBox = new Aspose.Pdf.Rectangle( leftNonWhite.Value + prevCropBox.LLX, (toHeight + prevCropBox.LLY) - bottomNonWhite.Value, rightNonWhite.Value + doc.Pages[i].CropBox.LLX, (toHeight + prevCropBox.LLY) - topNonWhite.Value ); } finally { if (imageBitmapData != null) { bmp.UnlockBits(imageBitmapData); } } } // Save the document doc.Save(@"D:\hoctap\webasp\CongVan\CongVan\Areas\Admin\Files\Tmp\spacePdf" + i + ".pdf"); }
public static Rectangle AutoCropRect(System.Drawing.Bitmap bitmap, System.Drawing.Color color, int seuil) { try { unsafe { int x, y, xMin, xMax, yMin, yMax, dR, dG, dB, cR, cG, cB, w, h, PixelSize, scanline, stride; bool broken; byte *p; // aide utile http://www.bobpowell.net/lockingbits.htm System.Drawing.Imaging.BitmapData bmd = bitmap.LockBits( new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, bitmap.PixelFormat); if (bitmap.PixelFormat == System.Drawing.Imaging.PixelFormat.Format32bppArgb) { PixelSize = 4; } else if (bitmap.PixelFormat == System.Drawing.Imaging.PixelFormat.Format24bppRgb) { PixelSize = 3; } else { bitmap.UnlockBits(bmd); return(Rectangle.Empty); } w = bmd.Width; h = bmd.Height; yMin = h; yMax = 0; xMin = w; xMax = 0; cR = color.R; cG = color.G; cB = color.B; stride = bmd.Stride; scanline = stride - bmd.Width * PixelSize; // detection bord haut broken = false; p = (byte *)bmd.Scan0; for (y = 0; y < h; y++) { for (x = 0; x < w; x++) { dR = p[2] - cR; dG = p[1] - cG; dB = p[0] - cB; if (dR > seuil || dR < -seuil || dG > seuil || dG < -seuil || dB > seuil || dB < -seuil) { yMin = y; broken = true; break; } p += PixelSize; } if (broken) { break; } p += scanline; } if (yMin == h) { // gros pb de detection : exemple image unie ... bitmap.UnlockBits(bmd); return(Rectangle.Empty); } // detection bord bas broken = false; p = (byte *)bmd.Scan0 + (h - 1) * stride; for (y = h - 1; y >= 0; y--) { for (x = 0; x < w; x++) { dR = p[2] - cR; dG = p[1] - cG; dB = p[0] - cB; if (dR > seuil || dR < -seuil || dG > seuil || dG < -seuil || dB > seuil || dB < -seuil) { yMax = y; broken = true; break; } p += PixelSize; } if (broken) { break; } if (y <= yMin) { yMax = y; break; } p -= stride + PixelSize * w; } if (yMin >= yMax) { // gros pb de detection : exemple image unie ... bitmap.UnlockBits(bmd); return(Rectangle.Empty); } // detection bord gauche broken = false; for (x = 0; x < w; x++) { p = (byte *)bmd.Scan0 + yMin * stride; for (y = yMin; y <= yMax; y++) { dR = p[x * PixelSize + 2] - cR; dG = p[x * PixelSize + 1] - cG; dB = p[x * PixelSize] - cB; if (dR > seuil || dR < -seuil || dG > seuil || dG < -seuil || dB > seuil || dB < -seuil) { xMin = x; broken = true; break; } p += stride; } if (broken) { break; } } if (xMin == w) { // gros pb de detection : exemple image unie ... bitmap.UnlockBits(bmd); return(Rectangle.Empty); } // detection bord droit broken = false; for (x = w - 1; x >= 0; x--) { p = (byte *)bmd.Scan0 + yMin * stride; for (y = yMin; y <= yMax; y++) { dR = p[x * PixelSize + 2] - cR; dG = p[x * PixelSize + 1] - cG; dB = p[x * PixelSize] - cB; if (dR > seuil || dR < -seuil || dG > seuil || dG < -seuil || dB > seuil || dB < -seuil) { xMax = x; broken = true; break; } p += stride; } if (broken) { break; } if (x <= xMin) { xMax = x; break; } } if (xMin >= xMax) { // gros pb de detection : exemple image unie ... bitmap.UnlockBits(bmd); return(Rectangle.Empty); } bitmap.UnlockBits(bmd); return(new System.Drawing.Rectangle(xMin, yMin, xMax - xMin + 1, yMax - yMin + 1)); } } catch { return(Rectangle.Empty); } }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); shader = new Shader(@"vertexShader.vs", @"fragShader.fs"); shader.Create(); GL.GenVertexArrays(1, out VAO); GL.BindVertexArray(VAO); GL.GenBuffers(1, out VBO); GL.BindBuffer(BufferTarget.ArrayBuffer, VBO); GL.BufferData(BufferTarget.ArrayBuffer, sizeof(float) * vertices.Length, vertices, BufferUsageHint.StaticDraw); GL.GenBuffers(1, out EBO); GL.BindBuffer(BufferTarget.ElementArrayBuffer, EBO); GL.BufferData(BufferTarget.ElementArrayBuffer, sizeof(uint) * indices.Length, indices, BufferUsageHint.StaticDraw); // position attribute GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, 8 * sizeof(float), 0); GL.EnableVertexAttribArray(0); // color attribute GL.VertexAttribPointer(1, 3, VertexAttribPointerType.Float, false, 8 * sizeof(float), 3 * sizeof(float)); GL.EnableVertexAttribArray(1); // texture attribute GL.VertexAttribPointer(2, 2, VertexAttribPointerType.Float, false, 8 * sizeof(float), 6 * sizeof(float)); GL.EnableVertexAttribArray(2); GL.GenTextures(1, out texture1); GL.BindTexture(TextureTarget.Texture2D, texture1); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear); Bitmap bitmap = new Bitmap(@"container.jpg"); Imaging.BitmapData data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), Imaging.ImageLockMode.ReadOnly, Imaging.PixelFormat.Format32bppRgb); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, bitmap.Width, bitmap.Height, 0, PixelFormat.Bgra, PixelType.UnsignedByte, data.Scan0); bitmap.UnlockBits(data); GL.GenTextures(1, out texture2); GL.BindTexture(TextureTarget.Texture2D, texture2); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, (int)TextureWrapMode.Repeat); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, (int)TextureWrapMode.Repeat); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, (int)TextureMinFilter.Linear); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, (int)TextureMagFilter.Linear); bitmap = new Bitmap(@"awesomeface.png"); bitmap.RotateFlip(RotateFlipType.Rotate180FlipX); data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), Imaging.ImageLockMode.ReadOnly, Imaging.PixelFormat.Format32bppRgb); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, bitmap.Width, bitmap.Height, 0, PixelFormat.Bgra, PixelType.UnsignedByte, data.Scan0); bitmap.UnlockBits(data); }
public void BuildRateMap() { // Create bitmap. isVRateSet = false; string fileAndDirectory = mf.fieldsDirectory + mf.currentFieldDirectory + "\\VR.JPG"; if (!File.Exists(fileAndDirectory)) { return; } //create a bitmap mage from the jpeg using (Bitmap bmpRate = (Bitmap)Image.FromFile(fileAndDirectory)) { // Lock the bitmap's bits. Rectangle rect = new Rectangle(0, 0, bmpRate.Width, bmpRate.Height); System.Drawing.Imaging.BitmapData bmpData = bmpRate.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmpRate.PixelFormat); if (bmpRate.PixelFormat != System.Drawing.Imaging.PixelFormat.Format24bppRgb) { return; } // Get the address of the first line. IntPtr ptr = bmpData.Scan0; // Declare an array to hold the bytes of the bitmap. int bytes = Math.Abs(bmpData.Stride) * bmpRate.Height; byte[] rgbValues = new byte[bytes]; // Copy the RGB values into the array. System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes); //save the width and height bmpWidth = bmpRate.Width * 3; bmpHeight = bmpRate.Height; //24 bits per pixel - 3 bytes format is BGR byte[] allBytes = new byte[(int)(bmpWidth * bmpHeight)]; byte[] flipped = new byte[(int)(bmpWidth * bmpHeight)]; ////extract the red values int rc = 0; for (var r = 0; r < bmpHeight; r++) //each scanline row { for (var c = 0; c < bmpWidth; c++) //each red pixel { allBytes[rc] = rgbValues[(r * bmpData.Stride) + c]; //remove padding bytes rc++; } } //flip the image top to bottom for (int i = 0, j = allBytes.Length - bmpWidth; i < allBytes.Length; i += bmpWidth, j -= bmpWidth) { for (int k = 0; k < bmpWidth; ++k) { flipped[i + k] = allBytes[j + k]; } } int bmpPixelCount = flipped.Length; double fieldHeight = (mf.maxFieldY - mf.minFieldY); // field height double fieldWidth = (mf.maxFieldX - mf.minFieldX); // field width int rateMapScale = 1; if (fieldHeight > fieldWidth) { rateMapScale = (int)(fieldHeight / 75); } else { rateMapScale = (int)(fieldWidth / 75); } if (rateMapScale < 4) { rateMapScale = 4; //blocks no smaller then 8 meters } //rateMapScale = 4; //how many points of height width of the field grid based on 8 meter square blocks int gridHeight = (int)fieldHeight / rateMapScale; int gridWidth = (int)fieldWidth / rateMapScale; //return to how many pixels wide from color triples //bmpWidth /= 3; //how much bigger or smaller the bmp is to the field grid double bmpToGridScaleWidth = ((double)bmpWidth) / (double)gridWidth / 3.0; double bmpToGridScaleHeight = (double)bmpHeight / (double)gridHeight; //put bitmap in 2d array for magnification or minification int[,] bmpArr = new int[bmpHeight, bmpWidth]; for (int i = 0; i < bmpHeight; i++) { for (int j = 0; j < bmpWidth; j++) { bmpArr[i, j] = flipped[(i * bmpWidth) + j]; } } // [y,x] or [height,width] or [i,j] mapList?.Clear(); for (int i = 0; i < gridHeight; i++) { for (int j = 0; j < gridWidth; j++) { //create map point CMapPt pt = new CMapPt((j * rateMapScale) + (int)mf.minFieldX, (i * rateMapScale) + (int)mf.minFieldY, bmpArr[(int)(i * bmpToGridScaleHeight), ((int)(j * bmpToGridScaleWidth) * 3) + 0], bmpArr[(int)(i * bmpToGridScaleHeight), ((int)(j * bmpToGridScaleWidth) * 3) + 1], bmpArr[(int)(i * bmpToGridScaleHeight), ((int)(j * bmpToGridScaleWidth) * 3) + 2] ); //add the point mapList.Add(pt); } } // Unlock the bits, add transparency, make png bmpRate.UnlockBits(bmpData); bmpRate.MakeTransparent(Color.Black); { bmpRate.Save("output.png", ImageFormat.Png); // Or Png } try { string text2 = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "Output.png"); if (File.Exists(text2)) { using (Bitmap bitmap2 = new Bitmap(text2)) { GL.GenTextures(1, out mf.texture[4]); GL.BindTexture(TextureTarget.Texture2D, mf.texture[4]); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, 9729); GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, 9729); BitmapData bitmapData2 = bitmap2.LockBits(new Rectangle(0, 0, bitmap2.Width, bitmap2.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, bitmapData2.Width, bitmapData2.Height, 0, OpenTK.Graphics.OpenGL.PixelFormat.Bgra, PixelType.UnsignedByte, bitmapData2.Scan0); bitmap2.UnlockBits(bitmapData2); } } } catch (Exception ex2) { //WriteErrorLog("Loading Floor Texture" + ex2); MessageBox.Show("Texture File OUPUT.PNG is Missing", ex2.Message); } } }
private void depthSet(ref DepthImagePixel[] data, int Width, int Height) { if (prevData == null) { prevData = data; } // Lock the bitmap's bits. Rectangle rect = new Rectangle(0, 0, Width, Height); System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat); // Get the address of the first line. IntPtr ptr = bmpData.Scan0; // Declare an array to hold the bytes of the bitmap. int bytes = Math.Abs(bmpData.Stride) * bmp.Height; byte[] rgbValues = new byte[bytes]; // Copy the RGB values into the array. System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes); for (int counter = 0, rgb = 0; counter < rgbValues.Length / 4; counter++, rgb += 4) { int clrComponent = (int)(data[counter].Depth * RGB_RATIO); //if ((prevData[counter].Depth == 0 && data[counter].Depth != 0) || (prevData[counter].Depth != 0 && data[counter].Depth == 0)) //{ // rgbValues[rgb] = 0; // rgbValues[rgb + 1] = 0; // rgbValues[rgb + 2] = 0; // continue; //} if (data[counter].Depth == 0) { //Look for non zero pixel int newIndex = findClearPoint(ref data, counter, Width, Height, 5); clrComponent = (int)(data[newIndex].Depth * RGB_RATIO); rgbValues[rgb] = (byte)clrComponent; rgbValues[rgb + 1] = (byte)clrComponent; rgbValues[rgb + 2] = (byte)clrComponent; continue; //bool flag = false; //for (int iterator = counter; iterator > 0; iterator--) //{ // if (data[iterator].Depth != 0) // { // int temp = (int)(data[iterator].Depth * RGB_RATIO); // rgbValues[rgb] = (byte)temp; // rgbValues[rgb + 1] = (byte)temp; // rgbValues[rgb + 2] = (byte)temp; // flag = true; // break; // } //} //if (!flag) //{ // rgbValues[rgb] = 0; // rgbValues[rgb + 1] = 0; // rgbValues[rgb + 2] = 0; //} //continue; } if (InvertColor) { clrComponent = 255 - clrComponent; } rgbValues[rgb] = (byte)clrComponent; rgbValues[rgb + 1] = (byte)clrComponent; rgbValues[rgb + 2] = (byte)clrComponent; //if (data[counter].IsKnownDepth) //{ // rgbValues[rgb] = (byte)clrComponent; // rgbValues[rgb + 1] = (byte)clrComponent; // rgbValues[rgb + 2] = (byte)clrComponent; //} //else //{ // rgbValues[rgb] = 255; // rgbValues[rgb + 1] = 255; // rgbValues[rgb + 2] = 255; //} } // Copy the RGB values back to the bitmap System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, bytes); // Unlock the bits. bmp.UnlockBits(bmpData); // Draw the modified image. contentGraphics.DrawImage(bmp, 0, 0); //Check Depth Change if (focusSet) { int fData = pointToIndex(Width, focusPoint); int Difference = Math.Abs(data[fData].Depth - focusPoint.Depth); if (Difference > 20) { //Debug.WriteLine("Depth Has Changed (New Distance : " + (float)data[fData].Depth / 1000 + " Meters)"); focusPoint.Depth = data[fData].Depth; } } isWorking = false; prevData = data; }
public void WriteImage(Image image) { if (image.PixelFormat != PixelFormat.Format32bppArgb) { throw new Exception("Pixel Format not yet supported."); } Image tempImage = image; float scale = tempImage.Height / tempImage.Width; if (tempImage.Width > 255) { tempImage = new Bitmap(image, new Size(255, (int)(255 / scale))); } if (tempImage.Height > 255) { tempImage = new Bitmap(image, new Size((int)(scale / 255), 255)); } image = tempImage; Bitmap bmp = new Bitmap(image); Rectangle rect = new Rectangle(0, 0, image.Width, bmp.Height); System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat); // Get the address of the first line. IntPtr ptr = bmpData.Scan0; // Declare an array to hold the bytes of the bitmap. int bytes = Math.Abs(bmpData.Stride) * bmp.Height; byte[] rgbValues = new byte[bytes]; // Copy the RGB values into the array. System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes); List <int[]> tempList = new List <int[]>(); List <int> tempList2 = new List <int>(); int nonzero = 0; for (int i = 0; i < rgbValues.Length;) { int byte1 = (((int)rgbValues[i]) << 24); int byte2 = (((int)rgbValues[i + 1]) << 16); int byte3 = (((int)rgbValues[i + 1]) << 8); int byte4 = (((int)rgbValues[i + 1])); int finalInt = byte1 | byte2 | byte3 | byte4; if (finalInt != -1) { nonzero++; } tempList2.Add(finalInt); if (((i += 4) % bmpData.Stride) == 0) { tempList.Add(tempList2.ToArray()); tempList2 = new List <int>(); } } int[][] thefinalarray = tempList.ToArray(); int[][] anotherarray = (int[][])thefinalarray.Clone(); for (int i = 0; i < anotherarray.Length; i++) { for (int j = 0; j < anotherarray[i].Length; j++) { if (anotherarray[i][j] != -1) { anotherarray[i][j] = 1; } else { anotherarray[i][j] = 0; } } } // Unlock the bits. bmp.UnlockBits(bmpData); betterPrintImage(anotherarray); }
private async Task <Form> RenderNewExpansion(int scale) { // var tasks = new List<Task<bool>>(); int imageArea = mWidth * mHeight; //int groupsize = imageArea / 2; //Environment.ProcessorCount; //int leftovers = imageArea % 2;//Environment.ProcessorCount; Form window = new Form(); tWidth = mWidth; if (scale == 2) { if ((mWidth * scale) % 4 != 0) { int tempMod = mWidth % 4; mWidth -= tempMod; } } PixelFormat format = imageDepth == 3 ? PixelFormat.Format24bppRgb : PixelFormat.Format32bppArgb; bigImage = new Bitmap(mWidth * scale, mHeight * scale, format); bBigImage = ConvToByteArray(bigImage); PictureBox newImageHolder = new PictureBox { Height = bigImage.Height, Width = bigImage.Width }; window.Height = bigImage.Height < 100?bigImage.Height:1000; window.Width = bigImage.Width; window.AutoScroll = true; // for (int a = 0; a < 2; a++) // { // if (a != 1 - 2) // tasks.Add(Task.Run(() => ProcessImageChunk((a * groupsize), (groupsize - 1) + (a * groupsize), a, scale))); // else // tasks.Add(Task.Run(() => ProcessImageChunk((a * groupsize), groupsize + (a * groupsize) + leftovers, a, scale))); // } //// Task.WaitAll(tasks.ToArray()); ProcessImageChunk(0, imageArea, 0, scale); var ms = new MemoryStream(bBigImage); Image image = Image.FromStream(ms); if (mWidth * scale % 4 != 0) { Bitmap temp = new Bitmap(image); Rectangle rect = new Rectangle(0, 0, mWidth, mHeight); System.Drawing.Imaging.BitmapData mInfo = temp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, temp.PixelFormat); for (int y = 0; y < mHeight; ++y) { IntPtr mem = (IntPtr)((long)mInfo.Scan0 + y * mInfo.Stride); Marshal.Copy(mem, bBigImage, y * mWidth * 3, mWidth * 3); } } mWidth = tWidth; ms = new MemoryStream(bBigImage); image = Image.FromStream(ms); if (flip) { image.RotateFlip(RotateFlipType.Rotate180FlipX); } newImageHolder.Image = image; window.Controls.Add(newImageHolder); return(window); }
public unsafe CVImage(System.Drawing.Bitmap sourceImage) { System.Drawing.Rectangle rect = new System.Drawing.Rectangle(); rect.X = 0; rect.Y = 0; rect.Width = sourceImage.Width; rect.Height = sourceImage.Height; System.Drawing.Imaging.BitmapData bData = sourceImage.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb); // New implementation: int pixelSizeInBytes = 8; int numberOfChannels = 3; this.image = PInvoke.cvCreateImage( new __CvSize(sourceImage.Width, sourceImage.Height), pixelSizeInBytes, numberOfChannels); CVUtils.CheckLastError(); unsafe { int height = sourceImage.Height; int width = sourceImage.Width; byte *pRead = (byte *)bData.Scan0.ToPointer(); byte *pWrite = this.Internal.ToPointer()->imageData; int nReadStride = bData.Stride - width * numberOfChannels; int nWriteStride = this.Internal.ToPointer()->widthStep - width * numberOfChannels; for (int row = 0; row < height; ++row, pRead += nReadStride, pWrite += nWriteStride) { for (int col = 0; col < width; ++col, pRead += numberOfChannels, pWrite += numberOfChannels) { pWrite[0] = pRead[0]; // Blue pWrite[1] = pRead[1]; // Green pWrite[2] = pRead[2]; // Red } } } #region Old Implementation //__IplImagePtr tempImage = PInvoke.cvCreateImageHeader(new __CvSize(sourceImage.Width, sourceImage.Height), 8, Bitmap.GetPixelFormatSize(sourceImage.PixelFormat) / 8); //tempImage.ToPointer()->imageData = (byte*)bData.Scan0.ToPointer(); //__IplImagePtr[] dst = new __IplImagePtr[4]; //for (int i = 0; i < 4; ++i) //{ // dst[i] = IntPtr.Zero; //} //for (int i = 0; i < tempImage.ToPointer()->nChannels; i++) //{ // dst[i] = PInvoke.cvCreateImage(new __CvSize(sourceImage.Width, sourceImage.Height), 8, 1); //} //PInvoke.cvSplit( // tempImage, // dst[0], // dst[1], // dst[2], // dst[3]); //image = PInvoke.cvCreateImage(new __CvSize(sourceImage.Width, sourceImage.Height), 8, 3); //PInvoke.cvMerge(dst[0], dst[1], dst[2], IntPtr.Zero, image) ; //for (int i = 0; i < tempImage.ToPointer()->nChannels; i++) //{ // PInvoke.cvReleaseImage(ref dst[i]); //} #endregion created = true; sourceImage.UnlockBits(bData); }
private Bitmap BmpFrame() { Bitmap bitmap = null; if (_iconData != null && _bestBitDepth == 32) { // GDI+ doesnt handle 32 bpp icons with alpha properly // we load the icon ourself from the byte table bitmap = new Bitmap(Size.Width, Size.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb); Debug.Assert(_bestImageOffset >= 0 && (_bestImageOffset + _bestBytesInRes) <= _iconData.Length, "Illegal offset/length for the Icon data"); unsafe { System.Drawing.Imaging.BitmapData bmpdata = bitmap.LockBits(new Rectangle(0, 0, Size.Width, Size.Height), System.Drawing.Imaging.ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); try { uint *pixelPtr = (uint *)bmpdata.Scan0.ToPointer(); // jumping the image header int newOffset = _bestImageOffset + Marshal.SizeOf(typeof(SafeNativeMethods.BITMAPINFOHEADER)); // there is no color table that we need to skip since we're 32bpp int lineLength = Size.Width * 4; int width = Size.Width; for (int j = (Size.Height - 1) * 4; j >= 0; j -= 4) { Marshal.Copy(_iconData, newOffset + j * width, (IntPtr)pixelPtr, lineLength); pixelPtr += width; } // note: we ignore the mask that's available after the pixel table } finally { bitmap.UnlockBits(bmpdata); } } } else if (_bestBitDepth == 0 || _bestBitDepth == 32) { // we don't know or we are 32bpp for sure //we don't have any icon data, let's fish out the data from the handle that we got... // we have to fish out the data for this icon if the icon is a 32bpp icon SafeNativeMethods.ICONINFO info = new SafeNativeMethods.ICONINFO(); SafeNativeMethods.GetIconInfo(new HandleRef(this, _handle), info); SafeNativeMethods.BITMAP bmp = new SafeNativeMethods.BITMAP(); try { if (info.hbmColor != IntPtr.Zero) { SafeNativeMethods.GetObject(new HandleRef(null, info.hbmColor), Marshal.SizeOf(typeof(SafeNativeMethods.BITMAP)), bmp); if (bmp.bmBitsPixel == 32) { Bitmap tmpBitmap = null; BitmapData bmpData = null; BitmapData targetData = null; try { tmpBitmap = Bitmap.FromHbitmap(info.hbmColor); // In GDI+ the bits are there but the bitmap was created with no alpha channel // so copy the bits by hand to a new bitmap // we also need to go around a limitation in the way the ICON is stored (ie if it's another bpp // but stored in 32bpp all pixels are transparent and not opaque) // (Here you mostly need to remain calm....) bmpData = tmpBitmap.LockBits(new Rectangle(0, 0, tmpBitmap.Width, tmpBitmap.Height), ImageLockMode.ReadOnly, tmpBitmap.PixelFormat); // we need do the following if the image has alpha because otherwise the image is fully transparent even though it has data if (BitmapHasAlpha(bmpData)) { bitmap = new Bitmap(bmpData.Width, bmpData.Height, PixelFormat.Format32bppArgb); targetData = bitmap.LockBits(new Rectangle(0, 0, bmpData.Width, bmpData.Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); CopyBitmapData(bmpData, targetData); } } finally { if (tmpBitmap != null && bmpData != null) { tmpBitmap.UnlockBits(bmpData); } if (bitmap != null && targetData != null) { bitmap.UnlockBits(targetData); } } tmpBitmap.Dispose(); } } } finally { if (info.hbmColor != IntPtr.Zero) { SafeNativeMethods.IntDeleteObject(new HandleRef(null, info.hbmColor)); } if (info.hbmMask != IntPtr.Zero) { SafeNativeMethods.IntDeleteObject(new HandleRef(null, info.hbmMask)); } } } if (bitmap == null) { // last chance... all the other cases (ie non 32 bpp icons coming from a handle or from the bitmapData) // we have to do this rather than just return Bitmap.FromHIcon because // the bitmap returned from that, even though it's 32bpp, just paints where the mask allows it // seems like another GDI+ weirdness. might be interesting to investigate further. In the meantime // this looks like the right thing to do and is not more expansive that what was present before. Size size = Size; bitmap = new Bitmap(size.Width, size.Height); // initialized to transparent Graphics graphics = null; try { graphics = Graphics.FromImage(bitmap); try { using (Bitmap tmpBitmap = Bitmap.FromHicon(Handle)) { graphics.DrawImage(tmpBitmap, new Rectangle(0, 0, size.Width, size.Height)); } } catch (ArgumentException) { // GDI+ weirdness episode MMMCLXXXXIVI, sometime FromHicon crash with no real reason, // backup plan is to just draw the image like we used to. // NOTE: FromHIcon is also where we have the buffer overrun // if width and height are mismatched Draw(graphics, new Rectangle(0, 0, size.Width, size.Height)); } } finally { if (graphics != null) { graphics.Dispose(); } } // gpr: GDI+ is filling the surface with a sentinel color for GetDC, // but is not correctly cleaning it up again, so we have to for it. Color fakeTransparencyColor = Color.FromArgb(0x0d, 0x0b, 0x0c); bitmap.MakeTransparent(fakeTransparencyColor); } Debug.Assert(bitmap != null, "Bitmap cannot be null"); return(bitmap); }
private Bitmap TrimImage(Bitmap img, int margin) { try { // Bitmap img = (Bitmap)Image.FromFile(path); //get image data System.Drawing.Imaging.BitmapData bd = img.LockBits(new Rectangle(Point.Empty, img.Size), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); int[] rgbValues = new int[img.Height * img.Width]; Marshal.Copy(bd.Scan0, rgbValues, 0, rgbValues.Length); img.UnlockBits(bd); #region determine bounds int left = bd.Width - margin; int top = bd.Height - margin; int right = margin; int bottom = margin; //determine top for (int i = 0; i < rgbValues.Length; i++) { int color = rgbValues[i] & 0xffffff; if (color != 0xffffff) { int r = i / bd.Width; int c = i % bd.Width; if (left > c) { left = c; } if (right < c) { right = c; } bottom = r; top = r; break; } } //determine bottom for (int i = rgbValues.Length - 1; i >= 0; i--) { int color = rgbValues[i] & 0xffffff; if (color != 0xffffff) { int r = i / bd.Width; int c = i % bd.Width; if (left > c) { left = c; } if (right < c) { right = c; } bottom = r; break; } } if (bottom > top) { for (int r = top + 1; r < bottom; r++) { //determine left for (int c = 0; c < left; c++) { int color = rgbValues[r * bd.Width + c] & 0xffffff; if (color != 0xffffff) { if (left > c) { left = c; break; } } } //determine right for (int c = bd.Width - 1; c > right; c--) { int color = rgbValues[r * bd.Width + c] & 0xffffff; if (color != 0xffffff) { if (right < c) { right = c; break; } } } } } int width = right - left + 1; int height = bottom - top + 1; #endregion //copy image data int[] imgData = new int[width * height]; for (int r = top; r <= bottom; r++) { Array.Copy(rgbValues, r * bd.Width + left, imgData, (r - top) * width, width); } //create new image Bitmap newImage = new Bitmap(width, height, PixelFormat.Format32bppArgb); BitmapData nbd = newImage.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); Marshal.Copy(imgData, 0, nbd.Scan0, imgData.Length); newImage.UnlockBits(nbd); img.Dispose(); img = null; return(newImage); } catch (Exception ex) { Log("TrimImage", ex.Message, true, ex); } return(null); }
static void Main(string[] args) { double[] Intensities = new double[90]; bool[] Phases = new bool[90]; // Calculation of mean intensity for each image for (int i = 1; i <= 90; i++) { if (i > 65) { Phases[i - 1] = false; } else { Phases[i - 1] = true; } String path = "c:\\Data/" + i.ToString() + ".jpeg"; Bitmap bmp = new Bitmap(path); Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height); System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat); // Get the address of the first line. IntPtr ptr = bmpData.Scan0; // Declare an array to hold the bytes of the bitmap. int bytes = Math.Abs(bmpData.Stride) * bmp.Height; byte[] rgbValues = new byte[bytes]; // Copy the RGB values into the array. System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes); double mean_r = 0.0, mean_g = 0.0, mean_b = 0.0, mean_f; int p_num = 0; for (int counter = 0; counter < rgbValues.Length; counter += 3) { mean_r += rgbValues[counter]; mean_g += rgbValues[counter + 1]; mean_b += rgbValues[counter + 2]; } p_num = bmp.Width * bmp.Height; mean_r /= p_num; mean_g /= p_num; mean_b /= p_num; mean_f = mean_r * 0.36 + 0.53 * mean_g + 0.11 * mean_b; Intensities[i - 1] = mean_f; //Console.WriteLine("mean_f: " + mean_f); bmp.UnlockBits(bmpData); } var range = new Microsoft.ML.Probabilistic.Models.Range(90); VariableArray <bool> DayPhase = Variable.Array <bool>(range); //DayPhase[range] = Variable.Bernoulli(0.5).ForEach(range); Variable <double> Mean = Variable.GaussianFromMeanAndVariance(100, 100).Named("Mean"); Variable <double> Sigma = Variable.GammaFromShapeAndScale(1, 1).Named("Sigma"); Variable <double> Threshold = Variable.GaussianFromMeanAndPrecision(Mean, Sigma).Named("Threshold"); VariableArray <double> v = Variable.Constant(Intensities, range); using (Variable.ForEach(range)) { using (Variable.If(v[range] >= Threshold)) { DayPhase[range] = true; } using (Variable.IfNot(v[range] >= Threshold)) { DayPhase[range] = false; } } DayPhase.ObservedValue = Phases; InferenceEngine engine = new InferenceEngine(); engine.Algorithm = new ExpectationPropagation(); //InferenceEngine.Visualizer = new WindowsVisualizer(); engine.ShowFactorGraph = false; Gaussian InfThreshold = engine.Infer <Gaussian>(Threshold); Gaussian InfMean = engine.Infer <Gaussian>(Mean); Console.WriteLine("inf threshold: " + InfThreshold); Console.WriteLine("inf mean: " + InfMean); Console.WriteLine(); }
/// <summary> /// Checks to see if bitmap contians a grayscale image. /// </summary> /// <param name="testImage">Image to test</param> /// <returns>true if grayscale.</returns> public unsafe static bool IsGrayScale(Bitmap testImage) { bool result = true; int h, w; int r, g, b; int margin = 2; // margin for error in intensity values (pixel color's within two points of eachother Rectangle rect; byte * ptr; // the use of pointers is what makes this "unsafe" code. System.Drawing.Imaging.BitmapData bmpData = null; // will hold the data about the bitmap image stored in managed memory. try { // Force the image to 32 bit ARGB memory bitmap format, lock it in manage memory, and validate that it is the type of image data expected. rect = new Rectangle(0, 0, testImage.Width, testImage.Height); bmpData = testImage.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); // lock it and get it's descriptor if (bmpData.Stride < 0) { throw new ApplicationException("ToSingle only works on images with a positive stride."); } if (bmpData.PixelFormat != System.Drawing.Imaging.PixelFormat.Format32bppArgb) { throw new ApplicationException("Wrong Pixel Format. ToSingle only works on 32 bit ARGB pixels."); } // Get a C style pointer to the image data ptr = (byte *)bmpData.Scan0.ToPointer(); // Test pixel color planes for same value // 32 bit Memory Bitmap image data is ordered blue byte, green byte, red byte, and Alpha channel byte (transparancy). for (h = 0; h < testImage.Height; h++) // cross the image rows { for (w = 0; w < testImage.Width; w++) // cross the image columns { b = *ptr++; g = *ptr++; r = *ptr++; ptr++; // skip the transparency byte if ((Math.Abs(r - b) + Math.Abs(b - g) + Math.Abs(g - r)) > margin) { result = false; } if (!result) { break; } } if (!result) { break; } } } catch (Exception ex) { throw ex; } finally { if (bmpData != null) { testImage.UnlockBits(bmpData); // Unlock the image data in managed code } } return(result); }
private static void SendTestPattern() { try { unsafe { Bitmap testPattern = new Bitmap(TEST_PATTERN_IMAGE_PATH); // Get the stride. Rectangle rect = new Rectangle(0, 0, testPattern.Width, testPattern.Height); System.Drawing.Imaging.BitmapData bmpData = testPattern.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, testPattern.PixelFormat); // Get the address of the first line. int stride = bmpData.Stride; testPattern.UnlockBits(bmpData); // Initialise the video codec and color converter. SIPSorceryMedia.VpxEncoder vpxEncoder = new VpxEncoder(); vpxEncoder.InitEncoder((uint)testPattern.Width, (uint)testPattern.Height, (uint)stride); SIPSorceryMedia.ImageConvert colorConverter = new ImageConvert(); byte[] sampleBuffer = null; byte[] encodedBuffer = null; int sampleCount = 0; uint rtpTimestamp = 0; while (!_exit) { if (OnTestPatternSampleReady != null) { var stampedTestPattern = testPattern.Clone() as System.Drawing.Image; AddTimeStampAndLocation(stampedTestPattern, DateTime.UtcNow.ToString("dd MMM yyyy HH:mm:ss:fff"), "Test Pattern"); sampleBuffer = BitmapToRGB24(stampedTestPattern as System.Drawing.Bitmap); fixed(byte *p = sampleBuffer) { byte[] convertedFrame = null; colorConverter.ConvertRGBtoYUV(p, VideoSubTypesEnum.BGR24, testPattern.Width, testPattern.Height, stride, VideoSubTypesEnum.I420, ref convertedFrame); fixed(byte *q = convertedFrame) { int encodeResult = vpxEncoder.Encode(q, convertedFrame.Length, 1, ref encodedBuffer); if (encodeResult != 0) { logger.LogWarning("VPX encode of video sample failed."); continue; } } } stampedTestPattern.Dispose(); stampedTestPattern = null; OnTestPatternSampleReady?.Invoke(SDPMediaTypesEnum.video, rtpTimestamp, encodedBuffer); encodedBuffer = null; sampleCount++; rtpTimestamp += VP8_TIMESTAMP_SPACING; } Thread.Sleep(30); } } } catch (Exception excp) { logger.LogError("Exception SendTestPattern. " + excp); } }
private Bitmap GrayPicture(string filename, int index, PictureOpticflowDataResultStruct[] PictureOpticflowDataResultArray) { Bitmap bmp = (Bitmap)Image.FromFile(filename); int PictureWidth = bmp.Width; int PictureHeight = bmp.Height; int strideValue; double max = 0, min = 255; float AverageOrigingray = 0; double SumCurentgray = 0; int lenth = PictureWidth * PictureHeight; if (lenth == PictureOpticflowDataResultArray[index].OpticflowResultFOfPixelArray.Length) { Apicturegrayinformation[] ApicturegrayinformationArray = new Apicturegrayinformation[lenth]; Rectangle rect = new Rectangle(0, 0, PictureWidth, PictureHeight); System.Drawing.Imaging.BitmapData bmpData = bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmp.PixelFormat); IntPtr ptr = bmpData.Scan0; if (grayed == true) // 灰度化显示 { if (PictureWidth % 4 == 0) { strideValue = PictureWidth * 3; byte[] rgbValues = new byte[lenth * 3]; System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, lenth * 3); //灰度化 Dogray(ref ApicturegrayinformationArray, rgbValues, strideValue, PictureWidth, PictureHeight, false, ref max, ref min, ref AverageOrigingray); //灰度拉伸 graystretch(ref ApicturegrayinformationArray, max, min, ref SumCurentgray); } else { strideValue = bmpData.Stride; int bytes = strideValue * PictureHeight; byte[] rgbValues = new byte[bytes]; System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes); //灰度化 Dogray(ref ApicturegrayinformationArray, rgbValues, strideValue, PictureWidth, PictureHeight, false, ref max, ref min, ref AverageOrigingray); //灰度拉伸 graystretch(ref ApicturegrayinformationArray, max, min, ref SumCurentgray); //光滑去噪 //showgussSmooth(ref ApicturegrayinformationArray); } bmp.UnlockBits(bmpData); bmp.Dispose(); GC.Collect(); curBitmap = CreateBmpByGrays(ApicturegrayinformationArray, index, PictureWidth, PictureHeight, PictureOpticflowDataResultArray); return(curBitmap); } // 灰度化显示 else // 彩色显示 { float tmp = 0; if (PictureWidth % 4 == 0) { strideValue = PictureWidth * 3; byte[] rgbValues = new byte[lenth * 3]; System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, lenth * 3); for (int i = 0; i < lenth; i++) { for (int j = 0; j < 3; j++) { if (biaodingDsp == true) { tmp = rgbValues[i * 3 + j]; } else { tmp = 0; } if (graydeltaAdd == true) // 灰度叠加 { if (forwardAdd == true) // 正向叠加 { tmp += PictureOpticflowDataResultArray[index].OpticflowResultFOfPixelArray[i].Greyvalue * FactorOfGreygrad; } else { tmp -= PictureOpticflowDataResultArray[index].OpticflowResultFOfPixelArray[i].Greyvalue * FactorOfGreygrad; } } if (tmp > 255) { rgbValues[i * 3 + j] = 255; } if (tmp < 0) { rgbValues[i * 3 + j] = 0; } if ((tmp >= 0) & (tmp <= 255)) { rgbValues[i * 3 + j] = (byte)tmp; } } } System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, lenth * 3); } else { strideValue = bmpData.Stride; int bytes = strideValue * PictureHeight; byte[] rgbValues = new byte[bytes]; System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes); for (int i = 0; i < rgbValues.Length; i++) { if (biaodingDsp == true) { tmp = rgbValues[i]; } else { tmp = 0; } if (graydeltaAdd == true) // 灰度叠加 { if (forwardAdd == true) // 正向叠加 { tmp += PictureOpticflowDataResultArray[index].OpticflowResultFOfPixelArray[i].Greyvalue * FactorOfGreygrad; } else { tmp -= PictureOpticflowDataResultArray[index].OpticflowResultFOfPixelArray[i].Greyvalue * FactorOfGreygrad; } } if (tmp > 255) { rgbValues[i] = 255; } if (tmp < 0) { rgbValues[i] = 0; } if ((tmp >= 0) & (tmp <= 255)) { rgbValues[i] = (byte)tmp; } } System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, bytes); } bmp.UnlockBits(bmpData); return(bmp); } } else { MessageBox.Show("计算灰度差的照片大小与当前照片大小不一致!!!"); return(bmp); } }
public ImageManip(string _imageLocation) { Location = _imageLocation; if (File.Exists(_imageLocation)) { //int offset = 0; Byte[] fsBuffer; //string[] Path = { _imageLocation, _name }; FileStream fs = File.Open(path: _imageLocation, mode: FileMode.Open, access: FileAccess.Read); // Start by reading file header.. fsBuffer = new Byte[14]; // size 40 bytes fs.Read(fsBuffer, 0, 14); bmpfh = new BMPFileHeader(fsBuffer); // Then image header, 40 bytes fsBuffer = new Byte[40]; fs.Read(fsBuffer, 0, 40); bmpih = new BMPImageHeader(fsBuffer); // How many bytes per pixel bytesperpixel = bmpih.BiBitCount / 8; // Read pixel array int totalBytes = (int)bmpih.BiWidth * (int)bmpih.BiHeight * bytesperpixel; int totalWidth = (int)bmpih.BiWidth; int totalHeight = (int)bmpih.BiHeight; fsBuffer = new Byte[totalBytes]; fs.Read(fsBuffer, 0, totalBytes); //int indeks = 0; if (totalHeight == totalWidth) { while (SIZE <= totalHeight) { SIZE *= 2; } } else if (totalHeight < totalWidth) { while (SIZE <= totalHeight) { SIZE *= 2; } } else if (totalHeight > totalWidth) { while (SIZE <= totalWidth) { SIZE *= 2; } } Pixel[,] Pix = new Pixel[totalHeight, totalWidth]; Complex[,] BigData = new Complex[SIZE, SIZE]; Complex[] Data = new Complex[SIZE]; if (bytesperpixel == 1) // If an image is in grayscale { for (int j = 0; j < (int)bmpih.BiHeight; j++) { for (int i = 0; i < (int)bmpih.BiWidth; i++) { // Pixel Pic = new Pixel(fsBuffer[j * (int)bmpih.BiWidth + i]); Pix[j, i] = Pic; } } } else // Otherwise if image is RGB { for (int j = 0; j < (int)bmpih.BiHeight; j++) { for (int i = 0; i < (int)bmpih.BiWidth; i++) { //if(i == 0 && j == 0) //{ //Pix[j, i] = if0; //Pix[j, i+1] = if1; // Complex data = new Complex() //} Pixel Pic = new Pixel(fsBuffer[j * (int)bmpih.BiWidth + i], fsBuffer[j * (int)bmpih.BiWidth + i + 1], fsBuffer[j * (int)bmpih.BiWidth + i + 2]); Pix[j, i] = Pic; double sum = Math.Sqrt(Math.Pow(Pix[j, i].Red, 2) + Math.Pow(Pix[j, i].Green, 2) + Math.Pow(Pix[j, i].Blue, 2)); //Pixel Buffer = new Pixel(fsBuffer[j * (int)bmpih.BiWidth + i + 3], fsBuffer[j * (int)bmpih.BiWidth + i + 4], fsBuffer[j * (int)bmpih.BiWidth + i + 5]); //if (i < SIZE && j < SIZE) //{ //double sumNext = Buffer.Red + Buffer.Green + Buffer.Blue; //Complex data = new Complex(sum, sumNext); Complex single = new Complex(sum); Complex bit = new Complex(fsBuffer[j * (int)bmpih.BiWidth + i]); //Data[indeks] = data; BigData[j, i] = bit; // Console.WriteLine(BigData[j, i].real + " " + BigData[j, i].imag); //} //indeks++; //Console.WriteLine("Pix["+ j + ", " + i + "].Red " + Pix[j,i].Red + " " + "Pix[" + j + ", " + i + "].Green " + Pix[j,i].Green + " " + "Pix[" + j + ", " + i + "].Blue " + Pix[j,i].Blue + ", suma: " + sum); //Complex complexPixel = new Complex(1, Pix[j-1,i-1], Pix[j,i]); } } } for (int j = 0; j < SIZE; j++) { for (int i = 0; i < SIZE; i++) { if (j >= totalHeight) { BigData[j, i] = new Complex(0); } if (i >= totalWidth) { BigData[j, i] = new Complex(0); } } } Complex[,] Fft = new Complex[SIZE, SIZE]; int[,] toInt2D = new int[SIZE, SIZE]; uint[] toInt = new uint[SIZE * SIZE]; for (int j = 0; j < SIZE; j++) // Transformacja wierszy { Complex[] tempRow = new Complex[SIZE]; for (int i = 0; i < SIZE; i++) { tempRow[i] = BigData[j, i]; } Complex[] tempFFT = Fourier.FFT(tempRow); for (int k = 0; k < SIZE; k++) { Fft[j, k] = tempFFT[k]; //Console.WriteLine(Fft[j, k].real + " " + Fft[j, k].imag); } } for (int j = 0; j < SIZE; j++) // Transformacja kolumn { Complex[] tempColumn = new Complex[SIZE]; for (int i = 0; i < SIZE; i++) { tempColumn[i] = Fft[i, j]; } Complex[] tempFFT = Fourier.FFT(tempColumn); for (int k = 0; k < SIZE; k++) { Fft[j, k] = tempFFT[k]; //toInt2D[k,j] = (int)Math.Abs(255*Fft[k, j].Phase); //Console.WriteLine(Fft[j, k].real + " " + Fft[j, k].imag); //Console.WriteLine("Gauss polar form: " + toInt[k]); } } //Wynik do tablicy int[,] toInt2D = Fourier.MagnitudePlot(Fft); byte[] pixelValues = new byte[2 * totalHeight * totalWidth]; int index = 0; for (int j = 0; j < totalHeight; j++) { for (int i = 0; i < totalWidth; i++) { pixelValues[index] = (byte)(((UInt16)(toInt2D[j, i]) & 0xFF00) >> 8); pixelValues[index + 1] = (byte)(((UInt16)(toInt2D[j, i]) & 0x00FF)); index += 2; //toInt[ind] = (uint)toInt2D[j, i]; //Color pixelColor = imageFinal.GetPixel(j, i); //Color newColor = Color.FromArgb(toInt2D[j, i]); //imageFinal.SetPixel(j, i, (Color)toInt2D[j,i]); //Console.WriteLine(toInt2D[j, i]); } } byte[] newPixelVal = new byte[totalHeight * totalWidth * 6]; newPixelVal = Convert16BitGrayScaleToRgb48(pixelValues, totalWidth, totalHeight); Bitmap img = new Bitmap(totalWidth, totalHeight, System.Drawing.Imaging.PixelFormat.Format48bppRgb); Rectangle dimension = new Rectangle(0, 0, img.Width, img.Height); System.Drawing.Imaging.BitmapData picData = img.LockBits(dimension, System.Drawing.Imaging.ImageLockMode.ReadWrite, img.PixelFormat); IntPtr pixelStartAddress = picData.Scan0; System.Runtime.InteropServices.Marshal.Copy(newPixelVal, 0, pixelStartAddress, newPixelVal.Length); img.UnlockBits(picData); img.Save(@"F:\pablito\downloads\bmp_manip\finall.bmp"); toInt2D = Fourier.PhasePlot(Fft); index = 0; for (int j = 0; j < totalHeight; j++) { for (int i = 0; i < totalWidth; i++) { pixelValues[index] = (byte)(((UInt16)(toInt2D[j, i]) & 0xFF00) >> 8); pixelValues[index + 1] = (byte)(((UInt16)(toInt2D[j, i]) & 0x00FF)); index += 2; //toInt[ind] = (uint)toInt2D[j, i]; //Color pixelColor = imageFinal.GetPixel(j, i); //Color newColor = Color.FromArgb(toInt2D[j, i]); //imageFinal.SetPixel(j, i, (Color)toInt2D[j,i]); //Console.WriteLine(toInt2D[j, i]); } } newPixelVal = Convert16BitGrayScaleToRgb48(pixelValues, totalWidth, totalHeight); Bitmap imag = new Bitmap(totalWidth, totalHeight, System.Drawing.Imaging.PixelFormat.Format48bppRgb); Rectangle dimension1 = new Rectangle(0, 0, imag.Width, img.Height); System.Drawing.Imaging.BitmapData imgData = imag.LockBits(dimension1, System.Drawing.Imaging.ImageLockMode.ReadWrite, imag.PixelFormat); IntPtr pixelStartAddress1 = imgData.Scan0; System.Runtime.InteropServices.Marshal.Copy(newPixelVal, 0, pixelStartAddress1, newPixelVal.Length); imag.UnlockBits(picData); imag.Save(@"F:\pablito\downloads\bmp_manip\finall2.bmp"); } }
private Bitmap CreateBmpByGrays(Apicturegrayinformation[] ApicturegrayinformationArray, int index, int PictureWidth, int PictureHeight, PictureOpticflowDataResultStruct[] PictureOpticflowDataResultArray) { Bitmap bit = new Bitmap(PictureWidth, PictureHeight, System.Drawing.Imaging.PixelFormat.Format8bppIndexed); //可读写的方式锁定全部容器 System.Drawing.Imaging.BitmapData data2 = bit.LockBits(new Rectangle(0, 0, bit.Width, bit.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, bit.PixelFormat); //得到首地址 IntPtr ptr2 = data2.Scan0; //计算24位图像的字节数 int bytes = PictureWidth * PictureHeight; //定义位图数组 byte[] grayValues = new byte[bytes]; //复制被锁定的图像到该数组 System.Runtime.InteropServices.Marshal.Copy(ptr2, grayValues, 0, bytes); float tmp; for (int i = 0; i < bytes; i++) { if (biaodingDsp == true) // 显示模板数据 { tmp = (byte)ApicturegrayinformationArray[i].OrigingrayValue; } else { tmp = 0; } if (graydeltaAdd == true) // 灰度差叠加 { if (forwardAdd == true) // 正向叠加 { tmp += PictureOpticflowDataResultArray[index].OpticflowResultFOfPixelArray[i].Greyvalue * FactorOfGreygrad; } else { tmp -= PictureOpticflowDataResultArray[index].OpticflowResultFOfPixelArray[i].Greyvalue * FactorOfGreygrad; } } if (tmp > 255) { grayValues[i] = 255; } if (tmp < 0) { grayValues[i] = 0; } if ((tmp >= 0) & (tmp <= 255)) { grayValues[i] = (byte)tmp; } } //送回数组 System.Runtime.InteropServices.Marshal.Copy(grayValues, 0, ptr2, bytes); //解锁 bit.UnlockBits(data2); ColorPalette tempPalette; using (Bitmap tempBmp = new Bitmap(1, 1, PixelFormat.Format8bppIndexed)) { tempPalette = tempBmp.Palette; } for (int i = 0; i < 256; i++) { tempPalette.Entries[i] = Color.FromArgb(i, i, i); } bit.Palette = tempPalette; return(bit); }
private void onCamMonitoring() { if (Data.Instance.Robot_work_info[strRobotID].robot_status_info.cam2 == null) { return; } CamInformation cam = Data.Instance.Robot_work_info[strRobotID].robot_status_info.cam2; byte[] bytecam = Convert.FromBase64String(cam.msg.data); int height = cam.msg.height; int width = cam.msg.width; nSourceMapWidth = width; nSourceMapHeight = height; sourceMapValues = new byte[width * height * 3]; for (var y = 0; y < width * height * 3; y++) { sourceMapValues[y] = bytecam[y]; } string startPath = Application.StartupPath; string path = string.Empty; path = startPath + @"\mapinfo.bmp"; try { Bitmap bmSource2 = new Bitmap(width, height, PixelFormat.Format24bppRgb); Rectangle rect2 = new Rectangle(0, 0, bmSource2.Width, bmSource2.Height); System.Drawing.Imaging.BitmapData bmpData2 = bmSource2.LockBits(rect2, System.Drawing.Imaging.ImageLockMode.ReadWrite, bmSource2.PixelFormat); IntPtr ptr = bmpData2.Scan0; { System.Runtime.InteropServices.Marshal.Copy(sourceMapValues, 0, ptr, width * height * 3); } bmSource2.UnlockBits(bmpData2); System.Drawing.Rectangle cropArea = new System.Drawing.Rectangle(0, 0, width, height); Bitmap bmpTemp = bmSource2.Clone(cropArea, bmSource2.PixelFormat); pictureBox1.Image = bmpTemp; bmSource2.Dispose(); bmSource2 = null; bmSource2 = (Bitmap)(bmpTemp.Clone()); // bmSource2.Save(path, ImageFormat.Bmp); } catch (Exception ex) { Console.Out.WriteLine("onCamMonitoring err :={0}", ex.Message.ToString()); } }
/// <summary> /// 灰度图转伪彩色图像函数(通过查表的方法) /// </summary> /// <param name="src"></param> /// <param name="type">转换类型(1.使用铁红 2.使用彩虹)</param> /// <returns></returns> private static Bitmap PGrayToPseudoColor2(Bitmap src, int type) { try { if (type == 1) { Bitmap a = new Bitmap(src); Rectangle rect = new Rectangle(0, 0, a.Width, a.Height); System.Drawing.Imaging.BitmapData bmpData = a.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format24bppRgb); int stride = bmpData.Stride; unsafe { byte *pIn = (byte *)bmpData.Scan0.ToPointer(); int temp; byte R, G, B; for (int y = 0; y < a.Height; y++) { for (int x = 0; x < a.Width; x++) { temp = pIn[0] / 2; R = ironTable[temp, 0]; G = ironTable[temp, 1]; B = ironTable[temp, 2]; pIn[0] = B; pIn[1] = G; pIn[2] = R; pIn += 3; } pIn += stride - a.Width * 3; } } a.UnlockBits(bmpData); return(a); } else if (type == 2) { Bitmap a = new Bitmap(src); Rectangle rect = new Rectangle(0, 0, a.Width, a.Height); System.Drawing.Imaging.BitmapData bmpData = a.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format24bppRgb); int stride = bmpData.Stride; unsafe { byte *pIn = (byte *)bmpData.Scan0.ToPointer(); int temp; byte R, G, B; for (int y = 0; y < a.Height; y++) { for (int x = 0; x < a.Width; x++) { temp = pIn[0] / 2; R = rainTable[temp, 0]; G = rainTable[temp, 1]; B = rainTable[temp, 2]; pIn[0] = B; pIn[1] = G; pIn[2] = R; pIn += 3; } pIn += stride - a.Width * 3; } } a.UnlockBits(bmpData); return(a); } else { throw new Exception("type 参数不合法!"); } } catch (Exception e) { return(null); } }