精华内容
下载资源
问答
  • C# 像素和毫米转换

    千次阅读 2019-09-26 16:07:26
    C# 像素和毫米转换 毫米=(像素/DPI)* 25.4 像素=(毫米数/25.4)*DPI 核心代码: /// <summary> /// 单位转换类 /// 毫米数 =(像素/DPI)* 25.4 /// 像素=(毫米数/25.4)*DPI /// </summary&...

    C# 像素和毫米转换

       毫米=(像素/DPI)* 25.4
        像素=(毫米数/25.4)*DPI

    核心代码:

        /// <summary>
        /// 单位转换类
        /// 毫米数 =(像素/DPI)* 25.4
        /// 像素=(毫米数/25.4)*DPI
        /// </summary>
        public class ToolUnitConversion
        {
            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="ImgPath">图片路径</param>
            /// <param name="DpiType">
            /// 1=获取显示器的 Dpi
            /// 2=获取图片的 Dpi
            /// </param>
            public ToolUnitConversion( string ImgPath, int DpiType)
            {
                this.DpiType = DpiType;
                this.ImgPath = ImgPath;
            }
    
            /// <summary>
            /// 构造函数
            /// </summary>
            /// <param name="Img">图片对象</param>
            /// <param name="DpiType">
            /// 1=获取显示器的 Dpi
            /// 2=获取图片的 Dpi
            /// </param>
            public ToolUnitConversion( Bitmap Img, int DpiType=2)
            {
                this.DpiType = DpiType;
                this.Img = Img;
            }
    
            float dpiX = 0;
            float dpiY = 0;
    
            /// <summary>
            /// 1英寸的物理长度:2.54厘米,这里表示25.4毫米
            /// </summary>
            public readonly double singleLengthD = 25.4;
    
            /// <summary>
            /// 1英寸的物理长度:2.54厘米,这里表示25.4毫米
            /// </summary>
            public readonly decimal singleLengthM = 25.4m;
    
            /// <summary>
            /// Dpi 类型
            /// 1=获取显示器的 Dpi
            /// 2=获取图片的 Dpi
            /// </summary>
            private int DpiType = 1;
    
            /// <summary>
            /// 图片路径
            /// </summary>
            private string ImgPath = "";
            /// <summary>
            /// 图片对象
            /// </summary>
            private Bitmap Img = null;
    
          
            /// <summary>
            /// 判断是否传入了图片
            /// </summary>
            /// <returns></returns>
            public bool IsImg()
            {
                try
                {
                    if (Img == null)
                    {
                        Img = (Bitmap)Image.FromFile(ImgPath);
                    }
                    if (Img!=null)
                    {
                        return true;
                    }
                }
                catch 
                {
    
                   
                }
                return false;
            }
    
    
            public  float DpiX
            {
                get
                {
                    if (dpiX == 0)
                    {
                        if (DpiType==2&& IsImg())
                        {
                            //获取图片的 Dpi
                            DpiX = Img.HorizontalResolution;
                            DpiY = Img.VerticalResolution;
                        }
                        else
                        {
                            //获取显示器的 Dpi
                            using (Graphics graphics = Graphics.FromHwnd(IntPtr.Zero))
                            {
                                DpiX = graphics.DpiX;
                                DpiY = graphics.DpiY;
                            }
                        }
                      
                    }
                    return dpiX;
                }
                set { dpiX = value; }
            }
            public  float DpiY
            {
                get
                {
                    var d = DpiX;
                    return dpiY;
                }
                set { dpiY = value; }
            }
    
            /// <summary>
            /// 毫米转像素
            /// 像素=(毫米数/25.4)*DPI
            /// </summary>
            /// <param name="mmLength">毫米</param>
            /// <param name="imageMultiple">图片物理倍数</param>
            /// <returns>PX</returns>
            public double MMToPX(double mmLength, int imageMultiple)
            {
                //像素=(毫米数/25.4)*DPI
                if (DpiY> DpiX)
                {
                    return ((mmLength / singleLengthD) * DpiY) * imageMultiple;
                }
                else
                {
                    return ((mmLength / singleLengthD) * DpiX) * imageMultiple;
                }
            }
    
            /// <summary>
            /// 像素转毫米
            /// </summary>
            /// <param name="pxLength">像素</param>
            /// <param name="imageMultiple">图片物理倍数</param>
            /// <returns>MM</returns>
            public double PXToMM(double pxLength, int imageMultiple)
            {
                //毫米数 =(像素 / DPI)*25.4
                if (DpiY > DpiX)
                {
                    return ((pxLength / DpiY) * singleLengthD) / imageMultiple;
                }
                else
                {
                    return ((pxLength / DpiX) * singleLengthD) / imageMultiple;
                }
            }
    
    
            /// <summary>
            /// 毫米转像素
            /// 像素=(毫米数/25.4)*DPI
            /// </summary>
            /// <param name="mmLength">毫米</param>
            /// <param name="imageMultiple">图片物理倍数</param>
            /// <returns>PX</returns>
            public decimal MMToPX(decimal mmLength, int imageMultiple)
            {
                //像素=(毫米数/25.4)*DPI
                if (DpiY > DpiX)
                {
                    return ((mmLength / singleLengthM) * (decimal)DpiY) * imageMultiple;
                }
                else
                {
                    return ((mmLength / singleLengthM) * (decimal)DpiX) * imageMultiple;
                }
            }
    
            /// <summary>
            /// 像素转毫米
            /// </summary>
            /// <param name="pxLength">像素</param>
            /// <param name="imageMultiple">图片物理倍数</param>
            /// <returns>MM</returns>
            public decimal PXToMM(decimal pxLength, int imageMultiple)
            {
                //毫米数 =(像素 / DPI)*25.4
                if (DpiY > DpiX)
                {
                    return ((pxLength / (decimal)DpiY) * singleLengthM) / imageMultiple;
                }
                else
                {
                    return ((pxLength / (decimal)DpiX) * singleLengthM) / imageMultiple;
                }
            }
    
    
            /// <summary>
            /// 像素平方转毫米平方
            /// </summary>
            /// <param name="pxLength">像素</param>
            /// <param name="imageMultiple">图片物理倍数</param>
            /// <returns>毫米平方</returns>
            public double AreaPXToMM(double pxLength, int imageMultiple)
            {
                //假设 宽是 1 高等于本身
                double w = 1;
                double h = pxLength;
    
                double Height = PXToMM(h, imageMultiple);//毫米  长
                double Width = PXToMM(w, imageMultiple);//毫米 宽
    
                return Height * Width;
            }
    
            /// <summary>
            /// 像素平方转毫米平方
            /// </summary>
            /// <param name="pxLength">像素</param>
            /// <param name="imageMultiple">图片物理倍数</param>
            /// <returns>毫米平方</returns>
            public decimal AreaPXToMM(decimal pxLength, int imageMultiple)
            {
                //假设 宽是 1 高等于本身
                decimal w = 1;
                decimal h = pxLength;
    
                decimal Height = PXToMM(h, imageMultiple);//毫米  长
                decimal Width = PXToMM(w, imageMultiple);//毫米 宽
    
                return Height * Width;
            }
    
    
            /// <summary>
            /// 毫米平方转像素平方
            /// </summary>
            /// <param name="mmLength">毫米</param>
            /// <param name="imageMultiple">图片物理倍数</param>
            /// <returns>像素平方</returns>
            public double AreaMMToPX(double mmLength, int imageMultiple)
            {
                //假设 宽是 1 高等于本身
                double w = 1;
                double h = mmLength;
    
                double Height = MMToPX(h, imageMultiple);//毫米  长
                double Width = MMToPX(w, imageMultiple);//毫米 宽
    
                return Height * Width;
            }
    
            /// <summary>
            /// 毫米平方转像素平方
            /// </summary>
            /// <param name="mmLength">毫米</param>
            /// <param name="imageMultiple">图片物理倍数</param>
            /// <returns>像素平方</returns>
            public decimal AreaMMToPX(decimal mmLength, int imageMultiple)
            {
                //假设 宽是 1 高等于本身
                decimal w = 1;
                decimal h = mmLength;
    
                decimal Height = MMToPX(h, imageMultiple);//毫米  长
                decimal Width = MMToPX(w, imageMultiple);//毫米 宽
    
                return Height * Width;
            }
        }

    下载链接:https://download.csdn.net/download/tanglingbo/11825949

    展开全文
  • 将图片的大小单位转换厘米,并实现计算图片大小面积,同时支持对文件的批量读取和数据结果的导出
  • 厘米像素换算器

    2019-09-22 13:57:45
    大家在PS中绘图,经常需要打印。如某某地方需要多少多少厘米,而照片的单位为像素,却不知道有多少厘米,又如一张图片,是800x600的,去饿不知道打印出来有多大。这些所有的问题,这个工具都能解决,只需提供DPI。
  • px和毫米之间的转换

    万次阅读 2019-06-02 22:32:50
    作为一名开人人员,我们经常会遇到客户莫名其妙的需求。 这不咱又遇到了,客户给的资料竟然是用厘米做的单位!! 于是只能自己去追寻单位转换之法,具体分享给朋友们

    作为一名开人人员,我们经常会遇到客户莫名其妙的需求。 这不咱又遇到了,客户给的资料竟然是用厘米做的单位!!
    于是只能自己去追寻单位转换之法,具体分享给朋友们 ?

    像素与毫米的转换
    转换还需要知道另一个参数:DPI(每英寸多少点)
    象素数 / DPI = 英寸数
    英寸数 * 25.4 = 毫米数


    对于显示设备,不管是打印机还是屏幕,都有一种通用的方法
    先用GetDeviceCaps(设备句柄,LOGPIXELSX)
    或者
    GetDeviceCaps(设备句柄,LOGPIXELSY)获得设备每英寸的像素数
    分别记为:px 和 py
    一英寸等于25.4mm


    那么毫米换算成像素的公式为
    水平方向的换算: x * px /25.4
    垂直方向的换算: y * py /25.4
    像素换算为毫米 x * 25.4 / px


    在程序中这么写
    MyControl.Height := 10{mm} * PixelsPerInch * 10 div 254;
    分子和分母同乘以10,将浮点数运算转化为整数运算,效率更高javascript可以得到的显示器参数

    screen.
    availHeight 获取系统屏幕的工作区域高度,排除 Microsoft® Windows® 任务栏。
    availWidth 获取系统屏幕的工作区域宽度,排除 Windows 任务栏。
    bufferDepth 设置或获取用于画面外位图缓冲颜色的每像素位数。
    colorDepth 获取用于目标设置或缓冲区的颜色每像素位数。
    deviceXDPI 设置或获取系统屏幕水平每英寸点数(DPI)的数值。
    deviceYDPI 设置或获取系统屏幕垂直每英寸点数(DPI)的数值。
    fontSmoothingEnabled 获取用户是否在控制面板的显示设置中启用了圆整屏幕字体边角的选项。
    height 获取屏幕的垂直分辨率。
    logicalXDPI 获取系统屏幕水平每英寸点数(DPI)的常规数值。
    logicalYDPI 获取系统屏幕垂直每英寸点数(DPI)的常规数值。
    updateInterval 设置或获取屏幕的更新间隔。
    width 获取屏幕的垂直分辨率。 常用的1024x768或800x600等标准的分辨率计算出来的dpi是一个常数:96,因此计算出来的毫米与像素的关系也约等于一个常数:
    基本上 1毫米 约等于 3.78像素
     

    展开全文
  • 从目前所掌握的资料来看,c#程序中将毫米转换像素的方法无非两种: 第一种: 1: /// <summary> 2: /// 以毫米为单位的显示宽度 3: /// </summary> 4: const int HORZSIZE = 4; 5...

    从目前所掌握的资料来看,c#程序中将毫米转换像素的方法无非两种:

    第一种:

       1: /// <summary>
       2: /// 以毫米为单位的显示宽度
       3: /// </summary>
       4: const int HORZSIZE = 4;
       5: /// <summary>
       6: /// 以像素为单位的显示宽度 0~65535
       7: /// </summary>
       8: const int HORZRES = 8;
       9: const int LOGPIXELSX = 88;
      10: const int LOGPIXELSY = 90;
      11: public static double MillimetersToPixelsWidth(IntPtr handle, double length) //length是毫米,1厘米=10毫米
      12: {
      13:     System.Drawing.Graphics g = System.Drawing.Graphics.FromHwnd(handle);
      14:     IntPtr hdc = g.GetHdc();
      15:     int width = GetDeviceCaps(hdc, HORZSIZE);     // HORZRES 
      16:     int pixels = GetDeviceCaps(hdc, HORZRES);     // BITSPIXEL
      17:     g.ReleaseHdc(hdc);
      18:     return (((double)pixels / (double)width) * (double)length);
      19: }
      20:  
      21: [System.Runtime.InteropServices.DllImport("gdi32.dll")]
      22: private static extern int GetDeviceCaps(IntPtr hdc, int Index);

    此种方法计算的值与实际刻度相比:10mm=实际刻度8mm

    以此技术的程序:桌面刻度尺

    技术文章引用:http://hi.baidu.com/kingcham/item/b3653ce0c69756216dabb8cd

    在文章中所说的

    GDI中有一个函数是GetDeviceCaps(),可以获取一些关于设备的一些属性,如HORZSIZE/HORZRES/LOGPIXELSX等。
        以上三者的关系通常满足:HORZSIZE = 25.4 * HORZRES/LOGPIXELSX

    但是在程序中却无法满足该条件。

     

    第二种:

       1: /// <summary>
       2: /// 1英寸=25.4毫米
       3: /// </summary>
       4: const double millimererTopixel = 25.4;
       5:  
       6: public static double MillimeterToPixel(IntPtr handle, double length) //length是毫米,1厘米=10毫米
       7: {
       8:    System.Windows.Forms.Panel p = new System.Windows.Forms.Panel();
       9:    System.Drawing.Graphics g = System.Drawing.Graphics.FromHwnd(handle);
      10:  
      11:    //1英寸=25.4mm=96DPI,那么1mm=96/25.4DPI
      12:    return (((double)g.DpiX / millimererTopixel) * (double)length);
      13: }

    此种方法是根据网上的换算关系得来的。得到的值与实际刻度相比:180mm=实际刻度185mm

    以此技术的程序:夏克屏幕刻度尺

     

    以目前而言,还无法准确的进行转换,从而绘制标准刻度尺。如果各位有更好的方法,还望提示下,先谢谢了。

    转载于:https://www.cnblogs.com/xiaotiannet/p/3520325.html

    展开全文
  • javascript 实现像素px与毫米mm的转换

    千次阅读 2019-02-15 10:50:52
    function unitConversion() {  /**  * 获取DPI  * @returns {Array}  */  this.conversion_getDPI =...// new unitConversion().mmConversionPx (毫米)   window.screen.deviceXDPI此方法只适用IE

    function unitConversion() {
        /**
         * 获取DPI
         * @returns {Array}
         */
        this.conversion_getDPI =function () {
            var arrDPI = new Array;
            if (window.screen.deviceXDPI) {
                arrDPI[0] = window.screen.deviceXDPI;
                arrDPI[1] = window.screen.deviceYDPI;
            } else {
                var tmpNode = document.createElement("DIV");
                tmpNode.style.cssText = "width:1in;height:1in;position:absolute;left:0px;top:0px;z-index:99;visibility:hidden";
                document.body.appendChild(tmpNode);
                arrDPI[0] = parseInt(tmpNode.offsetWidth);
                arrDPI[1] = parseInt(tmpNode.offsetHeight);
                tmpNode.parentNode.removeChild(tmpNode);
            }
            return arrDPI;
        };
        /**
         * px转换为mm
         * @param value
         * @returns {number}
         */
        this.pxConversionMm = function (value) {
            var inch = value/this.conversion_getDPI()[0];
            var c_value = inch * 25.4;
    //      console.log(c_value);
            return c_value;
        };
        /**
         * mm转换为px
         * @param value
         * @returns {number}
         */
        this.mmConversionPx = function (value) {
            var inch = value/25.4;
            var c_value = inch*this.conversion_getDPI()[0];
    //      console.log(c_value);
            return c_value;
        }
    }
     
    //调用直接 new unitConversion().pxConversionMm(像素) 
    //        new unitConversion().mmConversionPx (毫米)      
     

    window.screen.deviceXDPI此方法只适用IE

    展开全文
  • 厘米转换成像素

    2014-04-24 15:43:00
    /// <summary> /// 把像素换算成毫米 /// </summary> /// <param name="Pixel">多少像素</param> /// <returns>多少毫米</returns> public sta...
  • 实现当类型为1,输入英尺和英寸,转换为米和厘米;当类型为2,输入米和厘米转换为英尺和英寸。 已知: 1英尺 = 0.3048米; 1米 = 100厘米; 1英尺 = 12 英寸; 其具体实现代码如下: #include<iostream> ...
  • 像素与毫米转换公式

    万次阅读 2016-09-13 15:47:38
    像素与毫米转换 转换还需要知道另一个参数:DPI(每英寸多少点) 象素数 / DPI = 英寸数 英寸数 * 25.4 = 毫米数 对于显示设备,不管是打印机还是屏幕,都有一种通用的方法 先用GetDeviceCaps(设备句柄,...
  • 高斯正算毫米级精度批量转换公式
  • 这个长度转换器应用程序将给定长度(以米为单位)转换毫米厘米,英寸,英尺,码,公里等。此应用程序是使用HTML,CSS,BOOTSTRAP,JAVASCRIPT开发的。 访问以查看该应用程序的工作情况。
  • android 毫米(mm)转换为像素(px)

    千次阅读 2018-08-01 17:48:04
    TypedValue.applyDimension是一个将各种单位的值转换为像素的方法 int w = 20;//单位:mm float width = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_MM,w,getResources().getDisplayMetrics());  int ...
  • 使用C# 实现刻度尺,尺子上方刻度为像素,下方刻度为毫米,使用VS2013 编译,尺子是半透明的。dpi是写成固定的,没继续深入进去,一般情况可用
  • 英寸和厘米之间的转换

    千次阅读 2014-10-14 22:59:06
    import java.util.Scanner; ...System.out.println(a + "英寸 = " + a * 2.54 + "厘米"); System.out.printf("%.2f英寸 = %.2f厘米\n", a, a * 2.54); sc.close(); } }
  • Android dp到厘米转换

    千次阅读 2015-06-30 14:35:20
    首先计算dp到英寸的关系 DisplayMetrics metrics = getResources().getDisplayMetrics();  float result = metrics.density / metrics.xdpi; 1dp约为result英寸 ...因此,1dp约为result * 2.54f厘米
  • java 长度单位转换

    2011-07-22 11:31:23
    JAVA编写的长度单位转换,可从米转换为英制长度单位,码,英尺和英寸.
  • DPI 英寸 厘米 毫米

    2020-07-07 11:08:52
    简述dpi和英寸、厘米毫米之间的关系。
  • 厘米如何转换成像素

    千次阅读 2021-11-09 11:37:14
    厘米是长度单位,1厘米等于10毫米。 像素是指由图像的小方格组成的,这些小方块都有一个明确的位置和被分配的色彩数值,小方格颜色和位置就决定该图像所呈现出来的样子。 可以将像素视为整个图像中不可分割的单位...
  • 最近在开发打印功能的程序的时候需要用到将毫米转换为像素的计算公式,所以就将它记录下来: 分辨率 * (毫米*0.03937) = 像素
  • 1 <style type="text/css"> 2 #txt_cm1, #txt_inch1, #txt_inch2, #txt_cm2 { 3 width: 63px; 4 height: 26px; 5 margin: 0 5px; 6 border: solid 1px...
  • 使用快捷键:ctrl+k,调出默认值修改框;选择“单位和标”; 在“单位和标尺”中,选择**“像素**”,保存退出;
  • 为什么80%的码农都做不了架构师?>>>   ...英文字体的1磅,相当于1/72 英寸,约等于1/...1磅约等于0.03527厘米,1厘米约等于28.35磅, 转载于:https://my.oschina.net/ind/blog/204986
  • 毫米(Millimeter)。 cm   绝对长度单位。厘米(Centimeter)。               em/px/pt单位换算 1em=16px 1em=12pt 1px=1/16 em=0.0625em 1px=3/4 pt=0.75pt...
  • 图上(1767 - 771 = 996)对于10厘米,那么,那么1个像素相当于0.1毫米(这个整数只是巧合) 多次测量,验证算法的稳定性,并运用于实际项目。 小结 基于算法库和成熟的思路,能够加速解决问题速度。 比较好的视觉...
  • 如图,如果右边的下拉框选择不同的格式,左边的数值也会自动改变.如何做到
  • 毫米波雷达

    千次阅读 2019-03-27 10:12:42
    车载毫米波雷达的原理 车载毫米波雷达通过天线向外发射毫米波,接收目标反射信号,经后方处理后快速准确地获取汽车车身周围的物理环境信息(如汽车与其他物体之间的相对距离、相对速度、角度、运动方向等),然后...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,087
精华内容 1,234
关键字:

厘米转换毫米