常用的Emgu CV程式碼（主要有圖片格式轉換，圖片裁剪，圖片翻轉，圖片旋轉和圖片平移等功能）

阿新 • • 發佈：2018-12-08

using System;
using System.Drawing;
using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Structure;

namespace ZNLGIS
{
    public class ImageClass
    {
        //圖片裁剪
        public static Image<Bgr, Byte> Cut(Image<Bgr,Byte> image ,Rectangle rectangle)
        {
            System.Drawing.Size roisize = new 
 Size(260,380);
            IntPtr dst = CvInvoke.cvCreateImage(roisize, Emgu.CV.CvEnum.IPL_DEPTH.IPL_DEPTH_8U, 3);
            CvInvoke.cvSetImageROI(image.Ptr, rectangle);
            CvInvoke.cvCopy(image.Ptr, dst, IntPtr.Zero);

            return OpenCVEmguCVDotNet.IplImagePointerToEmgucvImage<Bgr, Byte>(dst);
        }
        //圖片裁剪 

        public static Image<Bgr, Byte> Cut2(Image<Bgr,Byte> image,int oldwidth,int oldheight)
        {
            int x = image.Width - oldwidth;
            int y = image.Height - oldheight;
            System.Drawing.Size roisize = new System.Drawing.Size(oldwidth, oldheight); //要裁剪的圖片大小 

            IntPtr dst = CvInvoke.cvCreateImage(roisize, Emgu.CV.CvEnum.IPL_DEPTH.IPL_DEPTH_8U, 3);
            System.Drawing.Rectangle rect = new System.Drawing.Rectangle(x/2, y/2, oldwidth, oldheight);
            CvInvoke.cvSetImageROI(image.Ptr, rect);
            CvInvoke.cvCopy(image.Ptr, dst, IntPtr.Zero);

            return OpenCVEmguCVDotNet.IplImagePointerToEmgucvImage<Bgr, Byte>(dst);
        }
        //圖片翻轉
        public static Image<Bgr, Byte> FlipImage(Image<Bgr, Byte> image, bool isHorizontal)
        {
            if (isHorizontal)
            {
                CvInvoke.cvFlip(image.Ptr, IntPtr.Zero, FLIP.HORIZONTAL);
            }
            else
            {
                CvInvoke.cvFlip(image.Ptr, IntPtr.Zero, FLIP.VERTICAL);
            }

            return image;
        }
        //圖片旋轉
        public static Image<Bgr, Byte> RotateImage(Image<Bgr, Byte> image_old, double angle, bool clockwise)
        {
            IntPtr image_temp;

            double anglerad = Math.PI * (angle / 180);
            int newwidth = (int)Math.Abs(image_old.Bitmap.Height * Math.Sin(anglerad)) +
                        (int)Math.Abs(image_old.Bitmap.Width * Math.Cos(anglerad)) + 1;
            int newheight = (int)Math.Abs(image_old.Bitmap.Height * Math.Cos(anglerad)) +
                        (int)Math.Abs(image_old.Bitmap.Width * Math.Sin(anglerad)) + 1;

            image_temp = CvInvoke.cvCreateImage(new Size(newwidth, newheight), IPL_DEPTH.IPL_DEPTH_8U, 3);
            CvInvoke.cvZero(image_temp);
            int flag = -1;

            if (clockwise)
            {
                flag = 1;
            }

            float[] m = new float[6];
            int w = image_old.Bitmap.Width;
            int h = image_old.Bitmap.Height;
            m[0] = (float)Math.Cos(flag * angle * Math.PI / 180);
            m[1] = (float)Math.Sin(flag * angle * Math.PI / 180);
            m[3] = -m[1];
            m[4] = m[0];

            m[2] = w * 0.5f;
            m[5] = h * 0.5f;

            unsafe
            {
                void* p;
                IntPtr ptr;
                fixed (float* pc = m)
                {
                    p = (void*)pc;
                    ptr = new IntPtr(p);
                }

                IntPtr M = CvInvoke.cvMat(2, 3, MAT_DEPTH.CV_32F, ptr);
                CvInvoke.cvGetQuadrangleSubPix(image_old.Ptr,image_temp,M);
            }

            return OpenCVEmguCVDotNet.IplImagePointerToEmgucvImage<Bgr, Byte>(image_temp);
        }
        //圖片平移
        public static Image<Bgr, Byte> Py(Image<Bgr, Byte> src,int x,int y)
        {
            System.Drawing.Size roisize = new Size(src.Width, src.Height);

            Image<Bgr, Byte> dst = new Image<Bgr, byte>(src.Width, src.Height, new Bgr(Color.Transparent));

            int i, j;
            int w = src.Width;
            int h = src.Height;

            if (x >= 0 && y >= 0)
            {
                for (i = 0; i < w - x; i++)
                {
                    for (j = 0; j < h - y; j++)
                    {
                        CvInvoke.cvSet2D(dst, j + y, i + x, CvInvoke.cvGet2D(src, j, i));
                    }
                }
            }
            else if (x >= 0 && y < 0)
            {
                for (i = 0; i < w - x; i++)
                {
                    for (j = -y; j < h; j++)
                    {
                        CvInvoke.cvSet2D(dst, j + y, i + x, CvInvoke.cvGet2D(src, j, i));
                    }
                }
            }
            else if (x < 0 && y >= 0)
            {
                for (i = -x; i < w; i++)
                {
                    for (j = 0; j < h - y; j++)
                    {
                        CvInvoke.cvSet2D(dst, j + y, i + x, CvInvoke.cvGet2D(src, j, i));
                    }
                }
            }
            else
            {
                for (i = -x; i < w; i++)
                {
                    for (j = -y; j < h; j++)
                    {
                        CvInvoke.cvSet2D(dst, j + y, i + x, CvInvoke.cvGet2D(src, j, i));
                    }
                }
            }

            return OpenCVEmguCVDotNet.IplImagePointerToEmgucvImage<Bgr, Byte>(dst);

        }
    }
}


using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using Emgu.CV;
using Emgu.CV.CvEnum;
using Emgu.CV.Structure;

namespace ZNLGIS
{
    public class OpenCVEmguCVDotNet
    {
        /// <summary>
        /// 將MIplImage結構轉換到IplImage指標；
        /// 注意：指標在使用完之後必須用Marshal.FreeHGlobal方法釋放。
        /// </summary>
        /// <param name="mi">MIplImage物件</param>
        /// <returns>返回IplImage指標</returns>
        public static IntPtr MIplImageToIplImagePointer(MIplImage mi)
        {
            IntPtr ptr = Marshal.AllocHGlobal(mi.nSize);
            Marshal.StructureToPtr(mi, ptr, false);
            return ptr;
        }

        /// <summary>
        /// 將IplImage指標轉換成MIplImage結構
        /// </summary>
        /// <param name="ptr">IplImage指標</param>
        /// <returns>返回MIplImage結構</returns>
        public static MIplImage IplImagePointerToMIplImage(IntPtr ptr)
        {
            return (MIplImage)Marshal.PtrToStructure(ptr, typeof(MIplImage));
        }

        /// <summary>
        /// 將IplImage指標轉換成Emgucv中的Image物件；
        /// 注意：這裡需要您自己根據IplImage中的depth和nChannels來決定
        /// </summary>
        /// <typeparam name="TColor">Color type of this image (either Gray, Bgr, Bgra, Hsv, Hls, Lab, Luv, Xyz or Ycc)</typeparam>
        /// <typeparam name="TDepth">Depth of this image (either Byte, SByte, Single, double, UInt16, Int16 or Int32)</typeparam>
        /// <param name="ptr">IplImage指標</param>
        /// <returns>返回Image物件</returns>
        public static Image<TColor, TDepth> IplImagePointerToEmgucvImage<TColor, TDepth>(IntPtr ptr)
            where TColor : struct, IColor
            where TDepth : new()
        {
            MIplImage mi = IplImagePointerToMIplImage(ptr);
            return new Image<TColor, TDepth>(mi.width, mi.height, mi.widthStep, mi.imageData);
        }

        /// <summary>
        /// 將IplImage指標轉換成Emgucv中的IImage介面；
        /// 1通道對應灰度影象，3通道對應BGR影象，4通道對應BGRA影象。
        /// 注意：3通道可能並非BGR影象，而是HLS,HSV等影象
        /// </summary>
        /// <param name="ptr">IplImage指標</param>
        /// <returns>返回IImage介面</returns>
        public static IImage IplImagePointToEmgucvIImage(IntPtr ptr)
        {
            MIplImage mi = IplImagePointerToMIplImage(ptr);
            Type tColor;
            Type tDepth;
            string unsupportedDepth = "不支援的畫素位深度IPL_DEPTH";
            string unsupportedChannels = "不支援的通道數（僅支援1，2，4通道）";
            switch (mi.nChannels)
            {
                case 1:
                    tColor = typeof(Gray);
                    switch (mi.depth)
                    {
                        case IPL_DEPTH.IPL_DEPTH_8U:
                            tDepth = typeof(Byte);
                            return new Image<Gray, Byte>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_16U:
                            tDepth = typeof(UInt16);
                            return new Image<Gray, UInt16>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_16S:
                            tDepth = typeof(Int16);
                            return new Image<Gray, Int16>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_32S:
                            tDepth = typeof(Int32);
                            return new Image<Gray, Int32>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_32F:
                            tDepth = typeof(Single);
                            return new Image<Gray, Single>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_64F:
                            tDepth = typeof(Double);
                            return new Image<Gray, Double>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        default:
                            throw new NotImplementedException(unsupportedDepth);
                    }
                case 3:
                    tColor = typeof(Bgr);
                    switch (mi.depth)
                    {
                        case IPL_DEPTH.IPL_DEPTH_8U:
                            tDepth = typeof(Byte);
                            return new Image<Bgr, Byte>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_16U:
                            tDepth = typeof(UInt16);
                            return new Image<Bgr, UInt16>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_16S:
                            tDepth = typeof(Int16);
                            return new Image<Bgr, Int16>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_32S:
                            tDepth = typeof(Int32);
                            return new Image<Bgr, Int32>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_32F:
                            tDepth = typeof(Single);
                            return new Image<Bgr, Single>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_64F:
                            tDepth = typeof(Double);
                            return new Image<Bgr, Double>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        default:
                            throw new NotImplementedException(unsupportedDepth);
                    }
                case 4:
                    tColor = typeof(Bgra);
                    switch (mi.depth)
                    {
                        case IPL_DEPTH.IPL_DEPTH_8U:
                            tDepth = typeof(Byte);
                            return new Image<Bgra, Byte>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_16U:
                            tDepth = typeof(UInt16);
                            return new Image<Bgra, UInt16>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_16S:
                            tDepth = typeof(Int16);
                            return new Image<Bgra, Int16>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_32S:
                            tDepth = typeof(Int32);
                            return new Image<Bgra, Int32>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_32F:
                            tDepth = typeof(Single);
                            return new Image<Bgra, Single>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        case IPL_DEPTH.IPL_DEPTH_64F:
                            tDepth = typeof(Double);
                            return new Image<Bgra, Double>(mi.width, mi.height, mi.widthStep, mi.imageData);
                        default:
                            throw new NotImplementedException(unsupportedDepth);
                    }
                default:
                    throw new NotImplementedException(unsupportedChannels);
            }
        }

        /// <summary>
        /// 將Emgucv中的Image物件轉換成IplImage指標；
        /// </summary>
        /// <typeparam name="TColor">Color type of this image (either Gray, Bgr, Bgra, Hsv, Hls, Lab, Luv, Xyz or Ycc)</typeparam>
        /// <typeparam name="TDepth">Depth of this image (either Byte, SByte, Single, double, UInt16, Int16 or Int32)</typeparam>
        /// <param name="image">Image物件</param>
        /// <returns>返回IplImage指標</returns>
        public static IntPtr EmgucvImageToIplImagePointer<TColor, TDepth>(Image<TColor, TDepth> image)
            where TColor : struct, IColor
            where TDepth : new()
        {
            return image.Ptr;
        }

        /// <summary>
        /// 將IplImage指標轉換成點陣圖物件；
        /// 對於不支援的畫素格式，可以先使用cvCvtColor函式轉換成支援的影象指標
        /// </summary>
        /// <param name="ptr">IplImage指標</param>
        /// <returns>返回點陣圖物件</returns>
        public static Bitmap IplImagePointerToBitmap(IntPtr ptr)
        {
            MIplImage mi = IplImagePointerToMIplImage(ptr);
            PixelFormat pixelFormat;    //畫素格式
            string unsupportedDepth = "不支援的畫素位深度IPL_DEPTH";
            string unsupportedChannels = "不支援的通道數（僅支援1，2，4通道）";
            switch (mi.nChannels)
            {
                case 1:
                    switch (mi.depth)
                    {
                        case IPL_DEPTH.IPL_DEPTH_8U:
                            pixelFormat = PixelFormat.Format8bppIndexed;
                            break;
                        case IPL_DEPTH.IPL_DEPTH_16U:
                            pixelFormat = PixelFormat.Format16bppGrayScale;
                            break;
                        default:
                            throw new NotImplementedException(unsupportedDepth);
                    }
                    break;
                case 3:
                    switch (mi.depth)
                    {
                        case IPL_DEPTH.IPL_DEPTH_8U:
                            pixelFormat = PixelFormat.Format24bppRgb;
                            break;
                        case IPL_DEPTH.IPL_DEPTH_16U:
                            pixelFormat = PixelFormat.Format48bppRgb;
                            break;
                        default:
                            throw new NotImplementedException(unsupportedDepth);
                    }
                    break;
                case 4:
                    switch (mi.depth)
                    {
                        case IPL_DEPTH.IPL_DEPTH_8U:
                            pixelFormat = PixelFormat.Format32bppArgb;
                            break;
                        case IPL_DEPTH.IPL_DEPTH_16U:
                            pixelFormat = PixelFormat.Format64bppArgb;
                            break;
                        default:
                            throw new NotImplementedException(unsupportedDepth);
                    }
                    break;
                default:
                    throw new NotImplementedException(unsupportedChannels);

            }
            Bitmap bitmap = new Bitmap(mi.width, mi.height, mi.widthStep, pixelFormat, mi.imageData);
            //對於灰度影象，還要修改調色盤
            if (pixelFormat == PixelFormat.Format8bppIndexed)
                SetColorPaletteOfGrayscaleBitmap(bitmap);
            return bitmap;
        }

        /// <summary>
        /// 將點陣圖轉換成IplImage指標
        /// </summary>
        /// <param name="bitmap">點陣圖物件</param>
        /// <returns>返回IplImage指標</returns>
        public static IntPtr BitmapToIplImagePointer(Bitmap bitmap)
        {
            IImage iimage = null;
            switch (bitmap.PixelFormat)
            {
                case PixelFormat.Format8bppIndexed:
                    iimage = new Image<Gray, Byte>(bitmap);
                    break;
                case PixelFormat.Format16bppGrayScale:
                    iimage = new Image<Gray, UInt16>(bitmap);
                    break;
                case PixelFormat.Format24bppRgb:
                    iimage = new Image<Bgr, Byte>(bitmap);
                    break;
                case PixelFormat.Format32bppArgb:
                    iimage = new Image<Bgra, Byte>(bitmap);
                    break;
                case PixelFormat.Format48bppRgb:
                    iimage = new Image<Bgr, UInt16>(bitmap);
                    break;
                case PixelFormat.Format64bppArgb:
                    iimage = new Image<Bgra, UInt16>(bitmap);
                    break;
                default:
                    Image<Bgra, Byte> tmp1 = new Image<Bgra, Byte>(bitmap.Size);
                    Byte[, ,] data = tmp1.Data;
                    for (int i = 0; i < bitmap.Width; i++)
                    {
                        for (int j = 0; j < bitmap.Height; j++)
                        {
                            Color color = bitmap.GetPixel(i, j);
                            data[j, i, 0] = color.B;
                            data[j, i, 1] = color.G;
                            data[j, i, 2] = color.R;
                            data[j, i, 3] = color.A;
                        }
                    }
                    iimage = tmp1;
                    break;
            }
            return iimage.Ptr;
        }

        /// <summary>
        /// 設定256級灰度點陣圖的調色盤
        /// </summary>
        /// <param name="bitmap"></param>
        public static void SetColorPaletteOfGrayscaleBitmap(Bitmap bitmap)
        {
            PixelFormat pixelFormat = bitmap.PixelFormat;
            if (pixelFormat == PixelFormat.Format8bppIndexed)
            {
                ColorPalette palette = bitmap.Palette;
                for (int i = 0; i < palette.Entries.Length; i++)
                    palette.Entries[i] = Color.FromArgb(255, i, i, i);
                bitmap.Palette = palette;
            }
        }
    }
}

常用的Emgu CV程式碼（主要有圖片格式轉換，圖片裁剪，圖片翻轉，圖片旋轉和圖片平移等功能）

轉載自部落格 using System; using System.Drawing; using Emgu.CV; using Emgu.CV.CvEnum; using Emgu.CV.Structure; namespace ZNLGIS { public class Im

使用TFRecord進行圖片格式轉換以及搭建神經網路實驗全過程，使用Tensorflow訓練自己的資料集

最近一個大作業需要進行影象處理可是網上的資源太分散，於是想整合網上資源，形成一個系統：主要包括圖片預處理圖片轉TFrecord格式 TFrecord格式轉圖片檢視簡單神經網路搭建 TFrecord格式在神經網路中的讀取 batch方法提取資料

連結到網頁中最常用的JS程式碼（js禁止右鍵、禁止複製）

<body oncontextmenu=”return false”></body> <!– 禁用右鍵: –> <script> function stop(){ return false; } document.oncontextmenu=st

10.spring:常用的資料庫程式碼.....（不長使用瞭解即可）

測試程式碼： ApplicationContext ctx = new ClassPathXmlApplicationContext("JDBC.xml"); DataSource datasource = (DataSource)ctx.getBean("dataSource",DataSource.cla

爬取天氣時常用的城市程式碼（備忘）

101010100=北京 101010200=海淀 101010300=朝陽 101010400=順義 101010500=懷柔 101010600=通州 101010700=昌平 101010800=延慶 101010900=豐臺 101011000=石景山 101011100=大興 10

網頁中最常用的JS程式碼（js禁止右鍵、禁止複製）

第一種也是簡單的新增事件：【【<body oncopy="returnfalse"> 禁止複製 <input type=""name=""id=""value=""onpaste="returnfalse"/> 禁止貼上 <body

V4L2影象採集+圖片格式轉換（YUYV、RGB、JPEG）

本篇轉自博友https://blog.csdn.net/xuyangwyw/article/details/40476653文章，感謝分享。廢話不多說，直接開始流程。 1、驅動支援在那位法國牙醫的無私奉獻下，Linux核心幾乎支援所

oracle sql小結（主要講橫列轉換的例子）decode 以及case

--建表 create table kecheng( id NUMBER, name VARCHAR2(20), course VARCHAR2(20), score NUMBER); --插入資料insert into kecheng (id, name, course, score)values (1

C語言和cuda C實現的程式碼（教科書上的格式）

一般教科書都這麼寫，感覺不如STL的好。記下以便查閱。 #include <cuda_runtime.h> #include <iostream> #include <stdio.h> __global__ void vector_add_gpu_2(fl

golang 執行命令列進行圖片格式轉換（jpg轉png)

1.golang 執行命令列 cmd := exec.Command(命令, 傳入引數1, 傳入引數2，...) cmd.Stdout = os.Stdout if err := cmd.Run(); err != nil {

jpg轉換pgm（其他圖片格式轉換類似）

最近在看sift，下載了lowe的程式碼，發現使用的影象時pgm格式的，自己的多數圖片是jpg格式的，就開始進行轉換。其實還是比較簡單明瞭的附程式碼如下function jpg2pgm( inputImage ) %JPG2PGM Summary of this fun

分享個C++封裝Libcurl程式碼（支援下載檔案、GET\POST、重定向斷點續傳等功能）

前言前面分享過一個Windows上封裝Winhttp和WinInet API的程式碼，結果下載頁好評特別多（呵呵），謝謝大家賞臉。文章地址：開源一個C++實現的簡單HTTP協議處理庫，裡面有程式碼資源下載地址。但是，在實際開發過程中我發現WinHttp API嚴重依賴微

jpg圖片格式轉換dwg怎麽操作

這款軟件小編我為什麽說比較好呢？是因為這款軟件不僅能夠轉換文件格式而且還能夠對文件進行編輯，功能強大且能快速轉換，下面就以jpg圖片格式轉換dwg怎麽操作為例來給大家介紹一下使用這款軟件的操作步驟。 CAD編輯器下載http://www.downxia.com/d

ffmpeg下載安裝和簡單應用（C#音頻格式轉換）

lan 音頻 sss sleep 自定義庫 blog version 就是可執行文件 ffmpeg下載安裝和簡單應用先介紹一下ffmpeg：FFmpeg是一個自由軟件，可以運行音頻和視頻多種格式的錄影、轉換、流功能，包含了libavcodec —這是一個用於多個項目

java之圖片格式轉換

圖片格式轉換package fileTest; import java.awt.Color; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOException; import java.util.Arra

怎樣將普通的圖片格式轉換成PDF格式

電腦桌 mar 行操作 .com 需要完成分享合並 word 大多時候我們處理格式間的轉換的對象多數為一些文件，如word、Excel、WPS等幾種辦公中常所使用到的。試過如何將圖片轉換成PDF格式了嗎？相信大部分的人都不知道如何操作，不妨試一下這種方法，小編將方法分

怎樣將圖片格式轉換成PDF格式？

電腦中儲存的圖片轉換成PDF格式該如何進行操作呢？下面就這個問題小編就將自己所知道的轉換方法告訴大家！1、首先可以將轉換成PDF格式的圖片儲存在一份新建的新資料夾中。2、接下來就可以藉助電腦端的PDF轉換軟體進行操作了。不過前提是電腦中要有PDF轉換器，沒有的話大家自行去下載。這個就不用小編教大家了吧！3、電

ASP NET2 0圖片格式轉換【月兒原創】

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！

WPF 圖片格式轉換

//FileStream imageStreamSource = File.OpenRead(srcPath); FileStrea

RGBA 圖片格式轉換 RGB 無損

拿到的圖片是webp格式的，然後系統無法處理。只能使用google code的dwebp工具，把圖片轉成png或者jpg的。這一步是ok了。但是轉成的圖片是RGBA的，系統只能處理RGB。。。報了下面的錯： java.lang.ArrayIndexOutOfBoundsEx

常用的Emgu CV程式碼（主要有圖片格式轉換，圖片裁剪，圖片翻轉，圖片旋轉和圖片平移等功能）

相關推薦