1. using System;
  2. using System.Drawing;
  3. using Emgu.CV;
  4. using Emgu.CV.CvEnum;
  5. using Emgu.CV.Structure;
  6.  
  7. namespace ZNLGIS
  8. {
  9.     public class ImageClass
  10.     {
  11.         //图片裁剪
  12.         public static Image<Bgr, Byte> Cut(Image<Bgr,Byte> image ,Rectangle rectangle)
  13.         {
  14.             System.Drawing.Size roisize = new Size(260,380);
  15.             IntPtr dst = CvInvoke.cvCreateImage(roisize, Emgu.CV.CvEnum.IPL_DEPTH.IPL_DEPTH_8U, 3);
  16.             CvInvoke.cvSetImageROI(image.Ptr, rectangle);
  17.             CvInvoke.cvCopy(image.Ptr, dst, IntPtr.Zero);
  18.  
  19.             return OpenCVEmguCVDotNet.IplImagePointerToEmgucvImage<Bgr, Byte>(dst);
  20.         }
  21.         //图片裁剪
  22.         public static Image<Bgr, Byte> Cut2(Image<Bgr,Byte> image,int oldwidth,int oldheight)
  23.         {
  24.             int x = image.Width - oldwidth;
  25.             int y = image.Height - oldheight;
  26.             System.Drawing.Size roisize = new System.Drawing.Size(oldwidth, oldheight); //要裁剪的图片大小
  27.             IntPtr dst = CvInvoke.cvCreateImage(roisize, Emgu.CV.CvEnum.IPL_DEPTH.IPL_DEPTH_8U, 3);
  28.             System.Drawing.Rectangle rect = new System.Drawing.Rectangle(x/2, y/2, oldwidth, oldheight);
  29.             CvInvoke.cvSetImageROI(image.Ptr, rect);
  30.             CvInvoke.cvCopy(image.Ptr, dst, IntPtr.Zero);
  31.  
  32.             return OpenCVEmguCVDotNet.IplImagePointerToEmgucvImage<Bgr, Byte>(dst);
  33.         }
  34.         //图片翻转
  35.         public static Image<Bgr, Byte> FlipImage(Image<Bgr, Byte> image, bool isHorizontal)
  36.         {
  37.             if (isHorizontal)
  38.             {
  39.                 CvInvoke.cvFlip(image.Ptr, IntPtr.Zero, FLIP.HORIZONTAL);
  40.             }
  41.             else
  42.             {
  43.                 CvInvoke.cvFlip(image.Ptr, IntPtr.Zero, FLIP.VERTICAL);
  44.             }
  45.  
  46.             return image;
  47.         }
  48.         //图片旋转
  49.         public static Image<Bgr, Byte> RotateImage(Image<Bgr, Byte> image_old, double angle, bool clockwise)
  50.         {
  51.             IntPtr image_temp;
  52.  
  53.             double anglerad = Math.PI * (angle / 180);
  54.             int newwidth = (int)Math.Abs(image_old.Bitmap.Height * Math.Sin(anglerad)) +
  55.                         (int)Math.Abs(image_old.Bitmap.Width * Math.Cos(anglerad)) + 1;
  56.             int newheight = (int)Math.Abs(image_old.Bitmap.Height * Math.Cos(anglerad)) +
  57.                         (int)Math.Abs(image_old.Bitmap.Width * Math.Sin(anglerad)) + 1;
  58.  
  59.             image_temp = CvInvoke.cvCreateImage(new Size(newwidth, newheight), IPL_DEPTH.IPL_DEPTH_8U, 3);
  60.             CvInvoke.cvZero(image_temp);
  61.             int flag = -1;
  62.  
  63.             if (clockwise)
  64.             {
  65.                 flag = 1;
  66.             }
  67.  
  68.             float[] m = new float[6];
  69.             int w = image_old.Bitmap.Width;
  70.             int h = image_old.Bitmap.Height;
  71.             m[0] = (float)Math.Cos(flag * angle * Math.PI / 180);
  72.             m[1] = (float)Math.Sin(flag * angle * Math.PI / 180);
  73.             m[3] = -m[1];
  74.             m[4] = m[0];
  75.  
  76.             m[2] = w * 0.5f;
  77.             m[5] = h * 0.5f;
  78.  
  79.             unsafe
  80.             {
  81.                 void* p;
  82.                 IntPtr ptr;
  83.                 fixed (float* pc = m)
  84.                 {
  85.                     p = (void*)pc;
  86.                     ptr = new IntPtr(p);
  87.                 }
  88.  
  89.                 IntPtr M = CvInvoke.cvMat(2, 3, MAT_DEPTH.CV_32F, ptr);
  90.                 CvInvoke.cvGetQuadrangleSubPix(image_old.Ptr,image_temp,M);
  91.             }
  92.  
  93.             return OpenCVEmguCVDotNet.IplImagePointerToEmgucvImage<Bgr, Byte>(image_temp);
  94.         }
  95.         //图片平移
  96.         public static Image<Bgr, Byte> Py(Image<Bgr, Byte> src,int x,int y)
  97.         {
  98.             System.Drawing.Size roisize = new Size(src.Width, src.Height);
  99.  
  100.             Image<Bgr, Byte> dst = new Image<Bgr, byte>(src.Width, src.Height, new Bgr(Color.Transparent));
  101.  
  102.             int i, j;
  103.             int w = src.Width;
  104.             int h = src.Height;
  105.  
  106.             if (x >= 0 && y >= 0)
  107.             {
  108.                 for (i = 0; i < w - x; i++)
  109.                 {
  110.                     for (j = 0; j < h - y; j++)
  111.                     {
  112.                         CvInvoke.cvSet2D(dst, j + y, i + x, CvInvoke.cvGet2D(src, j, i));
  113.                     }
  114.                 }
  115.             }
  116.             else if (x >= 0 && y < 0)
  117.             {
  118.                 for (i = 0; i < w - x; i++)
  119.                 {
  120.                     for (j = -y; j < h; j++)
  121.                     {
  122.                         CvInvoke.cvSet2D(dst, j + y, i + x, CvInvoke.cvGet2D(src, j, i));
  123.                     }
  124.                 }
  125.             }
  126.             else if (x < 0 && y >= 0)
  127.             {
  128.                 for (i = -x; i < w; i++)
  129.                 {
  130.                     for (j = 0; j < h - y; j++)
  131.                     {
  132.                         CvInvoke.cvSet2D(dst, j + y, i + x, CvInvoke.cvGet2D(src, j, i));
  133.                     }
  134.                 }
  135.             }
  136.             else
  137.             {
  138.                 for (i = -x; i < w; i++)
  139.                 {
  140.                     for (j = -y; j < h; j++)
  141.                     {
  142.                         CvInvoke.cvSet2D(dst, j + y, i + x, CvInvoke.cvGet2D(src, j, i));
  143.                     }
  144.                 }
  145.             }
  146.  
  147.             return OpenCVEmguCVDotNet.IplImagePointerToEmgucvImage<Bgr, Byte>(dst);
  148.  
  149.         }
  150.     }
  151. }
  1. using System;
  2. using System.Drawing;
  3. using System.Drawing.Imaging;
  4. using System.Runtime.InteropServices;
  5. using Emgu.CV;
  6. using Emgu.CV.CvEnum;
  7. using Emgu.CV.Structure;
  8.  
  9. namespace ZNLGIS
  10. {
  11.     public class OpenCVEmguCVDotNet
  12.     {
  13.         /// <summary>
  14.         /// 将MIplImage结构转换到IplImage指针；
  15.         /// 注意：指针在使用完之后必须用Marshal.FreeHGlobal方法释放。
  16.         /// </summary>
  17.         /// <param name="mi">MIplImage对象</param>
  18.         /// <returns>返回IplImage指针</returns>
  19.         public static IntPtr MIplImageToIplImagePointer(MIplImage mi)
  20.         {
  21.             IntPtr ptr = Marshal.AllocHGlobal(mi.nSize);
  22.             Marshal.StructureToPtr(mi, ptr, false);
  23.             return ptr;
  24.         }
  25.  
  26.         /// <summary>
  27.         /// 将IplImage指针转换成MIplImage结构
  28.         /// </summary>
  29.         /// <param name="ptr">IplImage指针</param>
  30.         /// <returns>返回MIplImage结构</returns>
  31.         public static MIplImage IplImagePointerToMIplImage(IntPtr ptr)
  32.         {
  33.             return (MIplImage)Marshal.PtrToStructure(ptr, typeof(MIplImage));
  34.         }
  35.  
  36.         /// <summary>
  37.         /// 将IplImage指针转换成Emgucv中的Image对象；
  38.         /// 注意：这里需要您自己根据IplImage中的depth和nChannels来决定
  39.         /// </summary>
  40.         /// <typeparam name="TColor">Color type of this image (either Gray, Bgr, Bgra, Hsv, Hls, Lab, Luv, Xyz or Ycc)</typeparam>
  41.         /// <typeparam name="TDepth">Depth of this image (either Byte, SByte, Single, double, UInt16, Int16 or Int32)</typeparam>
  42.         /// <param name="ptr">IplImage指针</param>
  43.         /// <returns>返回Image对象</returns>
  44.         public static Image<TColor, TDepth> IplImagePointerToEmgucvImage<TColor, TDepth>(IntPtr ptr)
  45.             where TColor : struct, IColor
  46.             where TDepth : new()
  47.         {
  48.             MIplImage mi = IplImagePointerToMIplImage(ptr);
  49.             return new Image<TColor, TDepth>(mi.width, mi.height, mi.widthStep, mi.imageData);
  50.         }
  51.  
  52.         /// <summary>
  53.         /// 将IplImage指针转换成Emgucv中的IImage接口；
  54.         /// 1通道对应灰度图像，3通道对应BGR图像，4通道对应BGRA图像。
  55.         /// 注意：3通道可能并非BGR图像，而是HLS,HSV等图像
  56.         /// </summary>
  57.         /// <param name="ptr">IplImage指针</param>
  58.         /// <returns>返回IImage接口</returns>
  59.         public static IImage IplImagePointToEmgucvIImage(IntPtr ptr)
  60.         {
  61.             MIplImage mi = IplImagePointerToMIplImage(ptr);
  62.             Type tColor;
  63.             Type tDepth;
  64.             string unsupportedDepth = "不支持的像素位深度IPL_DEPTH";
  65.             string unsupportedChannels = "不支持的通道数（仅支持1，2，4通道）";
  66.             switch (mi.nChannels)
  67.             {
  68.                 case 1:
  69.                     tColor = typeof(Gray);
  70.                     switch (mi.depth)
  71.                     {
  72.                         case IPL_DEPTH.IPL_DEPTH_8U:
  73.                             tDepth = typeof(Byte);
  74.                             return new Image<Gray, Byte>(mi.width, mi.height, mi.widthStep, mi.imageData);
  75.                         case IPL_DEPTH.IPL_DEPTH_16U:
  76.                             tDepth = typeof(UInt16);
  77.                             return new Image<Gray, UInt16>(mi.width, mi.height, mi.widthStep, mi.imageData);
  78.                         case IPL_DEPTH.IPL_DEPTH_16S:
  79.                             tDepth = typeof(Int16);
  80.                             return new Image<Gray, Int16>(mi.width, mi.height, mi.widthStep, mi.imageData);
  81.                         case IPL_DEPTH.IPL_DEPTH_32S:
  82.                             tDepth = typeof(Int32);
  83.                             return new Image<Gray, Int32>(mi.width, mi.height, mi.widthStep, mi.imageData);
  84.                         case IPL_DEPTH.IPL_DEPTH_32F:
  85.                             tDepth = typeof(Single);
  86.                             return new Image<Gray, Single>(mi.width, mi.height, mi.widthStep, mi.imageData);
  87.                         case IPL_DEPTH.IPL_DEPTH_64F:
  88.                             tDepth = typeof(Double);
  89.                             return new Image<Gray, Double>(mi.width, mi.height, mi.widthStep, mi.imageData);
  90.                         default:
  91.                             throw new NotImplementedException(unsupportedDepth);
  92.                     }
  93.                 case 3:
  94.                     tColor = typeof(Bgr);
  95.                     switch (mi.depth)
  96.                     {
  97.                         case IPL_DEPTH.IPL_DEPTH_8U:
  98.                             tDepth = typeof(Byte);
  99.                             return new Image<Bgr, Byte>(mi.width, mi.height, mi.widthStep, mi.imageData);
  100.                         case IPL_DEPTH.IPL_DEPTH_16U:
  101.                             tDepth = typeof(UInt16);
  102.                             return new Image<Bgr, UInt16>(mi.width, mi.height, mi.widthStep, mi.imageData);
  103.                         case IPL_DEPTH.IPL_DEPTH_16S:
  104.                             tDepth = typeof(Int16);
  105.                             return new Image<Bgr, Int16>(mi.width, mi.height, mi.widthStep, mi.imageData);
  106.                         case IPL_DEPTH.IPL_DEPTH_32S:
  107.                             tDepth = typeof(Int32);
  108.                             return new Image<Bgr, Int32>(mi.width, mi.height, mi.widthStep, mi.imageData);
  109.                         case IPL_DEPTH.IPL_DEPTH_32F:
  110.                             tDepth = typeof(Single);
  111.                             return new Image<Bgr, Single>(mi.width, mi.height, mi.widthStep, mi.imageData);
  112.                         case IPL_DEPTH.IPL_DEPTH_64F:
  113.                             tDepth = typeof(Double);
  114.                             return new Image<Bgr, Double>(mi.width, mi.height, mi.widthStep, mi.imageData);
  115.                         default:
  116.                             throw new NotImplementedException(unsupportedDepth);
  117.                     }
  118.                 case 4:
  119.                     tColor = typeof(Bgra);
  120.                     switch (mi.depth)
  121.                     {
  122.                         case IPL_DEPTH.IPL_DEPTH_8U:
  123.                             tDepth = typeof(Byte);
  124.                             return new Image<Bgra, Byte>(mi.width, mi.height, mi.widthStep, mi.imageData);
  125.                         case IPL_DEPTH.IPL_DEPTH_16U:
  126.                             tDepth = typeof(UInt16);
  127.                             return new Image<Bgra, UInt16>(mi.width, mi.height, mi.widthStep, mi.imageData);
  128.                         case IPL_DEPTH.IPL_DEPTH_16S:
  129.                             tDepth = typeof(Int16);
  130.                             return new Image<Bgra, Int16>(mi.width, mi.height, mi.widthStep, mi.imageData);
  131.                         case IPL_DEPTH.IPL_DEPTH_32S:
  132.                             tDepth = typeof(Int32);
  133.                             return new Image<Bgra, Int32>(mi.width, mi.height, mi.widthStep, mi.imageData);
  134.                         case IPL_DEPTH.IPL_DEPTH_32F:
  135.                             tDepth = typeof(Single);
  136.                             return new Image<Bgra, Single>(mi.width, mi.height, mi.widthStep, mi.imageData);
  137.                         case IPL_DEPTH.IPL_DEPTH_64F:
  138.                             tDepth = typeof(Double);
  139.                             return new Image<Bgra, Double>(mi.width, mi.height, mi.widthStep, mi.imageData);
  140.                         default:
  141.                             throw new NotImplementedException(unsupportedDepth);
  142.                     }
  143.                 default:
  144.                     throw new NotImplementedException(unsupportedChannels);
  145.             }
  146.         }
  147.  
  148.         /// <summary>
  149.         /// 将Emgucv中的Image对象转换成IplImage指针；
  150.         /// </summary>
  151.         /// <typeparam name="TColor">Color type of this image (either Gray, Bgr, Bgra, Hsv, Hls, Lab, Luv, Xyz or Ycc)</typeparam>
  152.         /// <typeparam name="TDepth">Depth of this image (either Byte, SByte, Single, double, UInt16, Int16 or Int32)</typeparam>
  153.         /// <param name="image">Image对象</param>
  154.         /// <returns>返回IplImage指针</returns>
  155.         public static IntPtr EmgucvImageToIplImagePointer<TColor, TDepth>(Image<TColor, TDepth> image)
  156.             where TColor : struct, IColor
  157.             where TDepth : new()
  158.         {
  159.             return image.Ptr;
  160.         }
  161.  
  162.         /// <summary>
  163.         /// 将IplImage指针转换成位图对象；
  164.         /// 对于不支持的像素格式，可以先使用cvCvtColor函数转换成支持的图像指针
  165.         /// </summary>
  166.         /// <param name="ptr">IplImage指针</param>
  167.         /// <returns>返回位图对象</returns>
  168.         public static Bitmap IplImagePointerToBitmap(IntPtr ptr)
  169.         {
  170.             MIplImage mi = IplImagePointerToMIplImage(ptr);
  171.             PixelFormat pixelFormat;    //像素格式
  172.             string unsupportedDepth = "不支持的像素位深度IPL_DEPTH";
  173.             string unsupportedChannels = "不支持的通道数（仅支持1，2，4通道）";
  174.             switch (mi.nChannels)
  175.             {
  176.                 case 1:
  177.                     switch (mi.depth)
  178.                     {
  179.                         case IPL_DEPTH.IPL_DEPTH_8U:
  180.                             pixelFormat = PixelFormat.Format8bppIndexed;
  181.                             break;
  182.                         case IPL_DEPTH.IPL_DEPTH_16U:
  183.                             pixelFormat = PixelFormat.Format16bppGrayScale;
  184.                             break;
  185.                         default:
  186.                             throw new NotImplementedException(unsupportedDepth);
  187.                     }
  188.                     break;
  189.                 case 3:
  190.                     switch (mi.depth)
  191.                     {
  192.                         case IPL_DEPTH.IPL_DEPTH_8U:
  193.                             pixelFormat = PixelFormat.Format24bppRgb;
  194.                             break;
  195.                         case IPL_DEPTH.IPL_DEPTH_16U:
  196.                             pixelFormat = PixelFormat.Format48bppRgb;
  197.                             break;
  198.                         default:
  199.                             throw new NotImplementedException(unsupportedDepth);
  200.                     }
  201.                     break;
  202.                 case 4:
  203.                     switch (mi.depth)
  204.                     {
  205.                         case IPL_DEPTH.IPL_DEPTH_8U:
  206.                             pixelFormat = PixelFormat.Format32bppArgb;
  207.                             break;
  208.                         case IPL_DEPTH.IPL_DEPTH_16U:
  209.                             pixelFormat = PixelFormat.Format64bppArgb;
  210.                             break;
  211.                         default:
  212.                             throw new NotImplementedException(unsupportedDepth);
  213.                     }
  214.                     break;
  215.                 default:
  216.                     throw new NotImplementedException(unsupportedChannels);
  217.  
  218.             }
  219.             Bitmap bitmap = new Bitmap(mi.width, mi.height, mi.widthStep, pixelFormat, mi.imageData);
  220.             //对于灰度图像，还要修改调色板
  221.             if (pixelFormat == PixelFormat.Format8bppIndexed)
  222.                 SetColorPaletteOfGrayscaleBitmap(bitmap);
  223.             return bitmap;
  224.         }
  225.  
  226.         /// <summary>
  227.         /// 将位图转换成IplImage指针
  228.         /// </summary>
  229.         /// <param name="bitmap">位图对象</param>
  230.         /// <returns>返回IplImage指针</returns>
  231.         public static IntPtr BitmapToIplImagePointer(Bitmap bitmap)
  232.         {
  233.             IImage iimage = null;
  234.             switch (bitmap.PixelFormat)
  235.             {
  236.                 case PixelFormat.Format8bppIndexed:
  237.                     iimage = new Image<Gray, Byte>(bitmap);
  238.                     break;
  239.                 case PixelFormat.Format16bppGrayScale:
  240.                     iimage = new Image<Gray, UInt16>(bitmap);
  241.                     break;
  242.                 case PixelFormat.Format24bppRgb:
  243.                     iimage = new Image<Bgr, Byte>(bitmap);
  244.                     break;
  245.                 case PixelFormat.Format32bppArgb:
  246.                     iimage = new Image<Bgra, Byte>(bitmap);
  247.                     break;
  248.                 case PixelFormat.Format48bppRgb:
  249.                     iimage = new Image<Bgr, UInt16>(bitmap);
  250.                     break;
  251.                 case PixelFormat.Format64bppArgb:
  252.                     iimage = new Image<Bgra, UInt16>(bitmap);
  253.                     break;
  254.                 default:
  255.                     Image<Bgra, Byte> tmp1 = new Image<Bgra, Byte>(bitmap.Size);
  256.                     Byte[, ,] data = tmp1.Data;
  257.                     for (int i = 0; i < bitmap.Width; i++)
  258.                     {
  259.                         for (int j = 0; j < bitmap.Height; j++)
  260.                         {
  261.                             Color color = bitmap.GetPixel(i, j);
  262.                             data[j, i, 0] = color.B;
  263.                             data[j, i, 1] = color.G;
  264.                             data[j, i, 2] = color.R;
  265.                             data[j, i, 3] = color.A;
  266.                         }
  267.                     }
  268.                     iimage = tmp1;
  269.                     break;
  270.             }
  271.             return iimage.Ptr;
  272.         }
  273.  
  274.         /// <summary>
  275.         /// 设置256级灰度位图的调色板
  276.         /// </summary>
  277.         /// <param name="bitmap"></param>
  278.         public static void SetColorPaletteOfGrayscaleBitmap(Bitmap bitmap)
  279.         {
  280.             PixelFormat pixelFormat = bitmap.PixelFormat;
  281.             if (pixelFormat == PixelFormat.Format8bppIndexed)
  282.             {
  283.                 ColorPalette palette = bitmap.Palette;
  284.                 for (int i = 0; i < palette.Entries.Length; i++)
  285.                     palette.Entries[i] = Color.FromArgb(255, i, i, i);
  286.                 bitmap.Palette = palette;
  287.             }
  288.         }
  289.     }
  290. }

自己积累的一些Emgu CV代码（主要有图片格式转换，图片裁剪，图片翻转，图片旋转和图片平移等功能）的更多相关文章

  1. 基于Emgu CV的人脸检测代码

    这个提供的代码例子是Emgu CV提供的源码里面自带的例子,很好用,基本不需要改,代码做的是人脸检测不是人脸识别,这个要分清楚.再就是新版本的Emgu CV可能会遇到系统32位和64位处理方式有区别的 ...

  2. [转载+原创]Emgu CV on C# （二） —— Emgu CV on 灰度化

    本文主要对彩色图片灰度化的方法及其实现过程进行总结,最终给出Emgu CV实现的代码. 一.灰度化原理及数学实现(转载自——<图像灰度化方法总结及其VC实现> 该篇文章使用opencv实现 ...

  3. 可学习的多人人脸识别程序(基于Emgu CV)

    源代码下载(需要安装Emgu CV,安装方法请百度) 很多朋友使用Emgu CV遇到CvInvoke()的报错,我找到一种解决方法. 把EmguCV目录下bin里面的所有dll复制到C:\WINDOW ...

  4. 基于Emgu CV 的手势识别实现PPT的控制放映

    Emgu CV 简介         众所周知,Emgu CV是.NET平台下对OpenCV图像处理库的封装,也就是.NET版的OpenCV.开发者可以很方便的通过C#,VB等语言调用OpenCV函数 ...

  5. C#下的 Emgu CV

    Emgu CV下载地址 http://sourceforge.net/projects/emgucv/files/ 找最新的下就行了,傻瓜式安装,选择目录后自动完成安装,然后提示安装VS2008和VS ...

  6. 【C# -- OpenCV】Emgu CV 第一个实例

    原文 [C# -- OpenCV]Emgu CV 第一个实例 Emgu CV下载地址 http://sourceforge.net/projects/emgucv/files/ 找最新的下就行了,傻瓜 ...

  7. Emgu.CV(二)

    小实例 class Program { static void Main(string[] args) { #region Emgu.Cv string imgPath = @"D:\tim ...

  8. 基于Emgu CV+百度人脸识别，实现视频动态 人脸抓取与识别

    背景 目前AI 处于风口浪尖,作为 公司的CTO,也作为自己的技术专研,开始了AI之旅,在朋友圈中也咨询 一些大牛对于AI 机器学习框架的看法,目前自己的研究方向主要开源的 AI 库,如:Emgu C ...

  9. [Winform]基于Emgu.CV人脸识别

    摘要 “OpenCV是一个开源的计算机视觉库.OpenCV采用C/C++语言编写,可以运行在Linux/Windows/Mac等操作系统上.OpenCV还提供了Python.Ruby.MATLAB以及 ...

随机推荐

  1. Android 6.0 权限管理最佳实践

    博客: Android 6.0 运行时权限管理最佳实践 github: https://github.com/yanzhenjie/AndPermission

  2. CSS3-06 样式 5

    浮动(Float) 关于浮动,要说的可能就是:一个设置了浮动的元素会尽量向左移动或向右移动,且会对其后的元素造成影响,其后的元素会排列在其围绕在其左下或右下部.似乎就这么简单,但是在实际开发中,它应用 ...

  3. 不同版本SQL SERVER备份还原时造成索引被禁用

    以下测试例子以SQL 2008备份,在SQL2014还原,造成索引被禁用. --备份环境(SQL Server 2008 R2) /* MicrosoftSQL Server 2008 R2 (RTM ...

  4. eclipse svn账号更换

    在eclipse下用 svn的时候,我们习惯将用户名和密码保存.前天公司将svn的账号全部更换了,这时原来的eclipse保存的svn账号密码就失效了.那怎么样才能切换账号了,eclipse svn插 ...

  5. OSI七层模型

    OSI 七层模型通过七个层次化的结构模型使不同的系统不同的网络之间实现可靠的通讯,因此其最主要的功能就是帮助不同类型的主机实现数据传输 . 完成中继功能的节点通常称为中继系统.在OSI七层模型中,处于 ...

  6. 数-模（D/A）转换器

    将实现数字信号到模拟信号的转换电流称为数模(D/A)转换器,简称为DAC(Digital - Analog Convert). 目前常见的D/A转化器中,有:权电阻网络D/A转换器.倒T型电阻网络D/ ...

  7. Java程序生成exe可执行文件详细教程(图文说明)

    ava程序打包成exe可执行文件,分为两大步骤. 第一步:将Java程序通过Eclipse或者Myeclipse导成Jar包 第二步:通过exe4j讲Jar包程序生成exe可执行文件 第一步详解: 将 ...

  8. 转载文章----十步完全理解SQL

    转载地址:http://blog.jobbole.com/55086/ 很多程序员视 SQL 为洪水猛兽.SQL 是一种为数不多的声明性语言,它的运行方式完全不同于我们所熟知的命令行语言.面向对象的程 ...

  9. Hibdernate入门

    Hibernate中java对象的三种状态 瞬时状态(Transient):通过NEW创建对象后对象并没有立刻持久化他未与数据哭中的数据有任何关联 持久状态(Persistent):当对象与Sessi ...

  10. 参数命令化 防止Sql注入

    1.先在数据库中完成储存过程 create proc usp_selectStudent ) as select * froom student where StudentName=@studentN ...