码迷,mamicode.com
首页 > 移动开发 > 详细

Android 厘米转dip、px转dip 地图比例尺长度计算

时间:2015-02-28 14:19:25      阅读:246      评论:0      收藏:0      [点我收藏+]

标签:

主要解决问题:

  1.Android各个长度单位转换为px(px、dip、mm等)

  2.px和dip的转换

使用的工具类:

  1.Android-API-工具类:TypedValue.applyDimension(int unit, float value,DisplayMetrics metrics);(大家最好读下附件中的TypedValue类源码)

  参数说明:

      (1)unit:输入值的类型(px、dip、mm、sp等)

      (2)value:对应的值

      (3)metrics:DisplayMetrics,

        DisplayMetrics官方解释:A structure describing general information about a display, such as its size, density, and font scaling.

      获取方法1:

      DisplayMetrics metrics = new DisplayMetrics();

      getWindowManager().getDefaultDisplay().getMetrics(metrics)

      获取方法2:

      context.getResources().getDisplayMetrics();

    详细介绍参见:

      http://www.eoeandroid.com/thread-246188-1-1.html

  2.DensityUtil类

    提供了px和dip的互转方法

    转自:http://blog.csdn.net/arui319/article/details/6777133

备注:

  有兴趣的朋友可以再封装下发布

 

附件:

  Android.util.TypedValue类源码如下:

技术分享
  1 /*
  2  * Copyright (C) 2007 The Android Open Source Project
  3  *
  4  * Licensed under the Apache License, Version 2.0 (the "License");
  5  * you may not use this file except in compliance with the License.
  6  * You may obtain a copy of the License at
  7  *
  8  *      http://www.apache.org/licenses/LICENSE-2.0
  9  *
 10  * Unless required by applicable law or agreed to in writing, software
 11  * distributed under the License is distributed on an "AS IS" BASIS,
 12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  * See the License for the specific language governing permissions and
 14  * limitations under the License.
 15  */
 16 
 17 package android.util;
 18 
 19 /**
 20  * Container for a dynamically typed data value.  Primarily used with
 21  * {@link android.content.res.Resources} for holding resource values.
 22  */
 23 public class TypedValue {
 24     /** The value contains no data. */
 25     public static final int TYPE_NULL = 0x00;
 26 
 27     /** The <var>data</var> field holds a resource identifier. */
 28     public static final int TYPE_REFERENCE = 0x01;
 29     /** The <var>data</var> field holds an attribute resource
 30      *  identifier (referencing an attribute in the current theme
 31      *  style, not a resource entry). */
 32     public static final int TYPE_ATTRIBUTE = 0x02;
 33     /** The <var>string</var> field holds string data.  In addition, if
 34      *  <var>data</var> is non-zero then it is the string block
 35      *  index of the string and <var>assetCookie</var> is the set of
 36      *  assets the string came from. */
 37     public static final int TYPE_STRING = 0x03;
 38     /** The <var>data</var> field holds an IEEE 754 floating point number. */
 39     public static final int TYPE_FLOAT = 0x04;
 40     /** The <var>data</var> field holds a complex number encoding a
 41      *  dimension value. */
 42     public static final int TYPE_DIMENSION = 0x05;
 43     /** The <var>data</var> field holds a complex number encoding a fraction
 44      *  of a container. */
 45     public static final int TYPE_FRACTION = 0x06;
 46 
 47     /** Identifies the start of plain integer values.  Any type value
 48      *  from this to {@link #TYPE_LAST_INT} means the
 49      *  <var>data</var> field holds a generic integer value. */
 50     public static final int TYPE_FIRST_INT = 0x10;
 51 
 52     /** The <var>data</var> field holds a number that was
 53      *  originally specified in decimal. */
 54     public static final int TYPE_INT_DEC = 0x10;
 55     /** The <var>data</var> field holds a number that was
 56      *  originally specified in hexadecimal (0xn). */
 57     public static final int TYPE_INT_HEX = 0x11;
 58     /** The <var>data</var> field holds 0 or 1 that was originally
 59      *  specified as "false" or "true". */
 60     public static final int TYPE_INT_BOOLEAN = 0x12;
 61 
 62     /** Identifies the start of integer values that were specified as
 63      *  color constants (starting with ‘#‘). */
 64     public static final int TYPE_FIRST_COLOR_INT = 0x1c;
 65 
 66     /** The <var>data</var> field holds a color that was originally
 67      *  specified as #aarrggbb. */
 68     public static final int TYPE_INT_COLOR_ARGB8 = 0x1c;
 69     /** The <var>data</var> field holds a color that was originally
 70      *  specified as #rrggbb. */
 71     public static final int TYPE_INT_COLOR_RGB8 = 0x1d;
 72     /** The <var>data</var> field holds a color that was originally
 73      *  specified as #argb. */
 74     public static final int TYPE_INT_COLOR_ARGB4 = 0x1e;
 75     /** The <var>data</var> field holds a color that was originally
 76      *  specified as #rgb. */
 77     public static final int TYPE_INT_COLOR_RGB4 = 0x1f;
 78 
 79     /** Identifies the end of integer values that were specified as color
 80      *  constants. */
 81     public static final int TYPE_LAST_COLOR_INT = 0x1f;
 82 
 83     /** Identifies the end of plain integer values. */
 84     public static final int TYPE_LAST_INT = 0x1f;
 85 
 86     /* ------------------------------------------------------------ */
 87 
 88     /** Complex data: bit location of unit information. */
 89     public static final int COMPLEX_UNIT_SHIFT = 0;
 90     /** Complex data: mask to extract unit information (after shifting by
 91      *  {@link #COMPLEX_UNIT_SHIFT}). This gives us 16 possible types, as
 92      *  defined below. */
 93     public static final int COMPLEX_UNIT_MASK = 0xf;
 94 
 95     /** {@link #TYPE_DIMENSION} complex unit: Value is raw pixels. */
 96     public static final int COMPLEX_UNIT_PX = 0;
 97     /** {@link #TYPE_DIMENSION} complex unit: Value is Device Independent
 98      *  Pixels. */
 99     public static final int COMPLEX_UNIT_DIP = 1;
100     /** {@link #TYPE_DIMENSION} complex unit: Value is a scaled pixel. */
101     public static final int COMPLEX_UNIT_SP = 2;
102     /** {@link #TYPE_DIMENSION} complex unit: Value is in points. */
103     public static final int COMPLEX_UNIT_PT = 3;
104     /** {@link #TYPE_DIMENSION} complex unit: Value is in inches. */
105     public static final int COMPLEX_UNIT_IN = 4;
106     /** {@link #TYPE_DIMENSION} complex unit: Value is in millimeters. */
107     public static final int COMPLEX_UNIT_MM = 5;
108 
109     /** {@link #TYPE_FRACTION} complex unit: A basic fraction of the overall
110      *  size. */
111     public static final int COMPLEX_UNIT_FRACTION = 0;
112     /** {@link #TYPE_FRACTION} complex unit: A fraction of the parent size. */
113     public static final int COMPLEX_UNIT_FRACTION_PARENT = 1;
114 
115     /** Complex data: where the radix information is, telling where the decimal
116      *  place appears in the mantissa. */
117     public static final int COMPLEX_RADIX_SHIFT = 4;
118     /** Complex data: mask to extract radix information (after shifting by
119      * {@link #COMPLEX_RADIX_SHIFT}). This give us 4 possible fixed point 
120      * representations as defined below. */ 
121     public static final int COMPLEX_RADIX_MASK = 0x3;
122 
123     /** Complex data: the mantissa is an integral number -- i.e., 0xnnnnnn.0 */
124     public static final int COMPLEX_RADIX_23p0 = 0;
125     /** Complex data: the mantissa magnitude is 16 bits -- i.e, 0xnnnn.nn */
126     public static final int COMPLEX_RADIX_16p7 = 1;
127     /** Complex data: the mantissa magnitude is 8 bits -- i.e, 0xnn.nnnn */
128     public static final int COMPLEX_RADIX_8p15 = 2;
129     /** Complex data: the mantissa magnitude is 0 bits -- i.e, 0x0.nnnnnn */
130     public static final int COMPLEX_RADIX_0p23 = 3;
131 
132     /** Complex data: bit location of mantissa information. */
133     public static final int COMPLEX_MANTISSA_SHIFT = 8;
134     /** Complex data: mask to extract mantissa information (after shifting by
135      *  {@link #COMPLEX_MANTISSA_SHIFT}). This gives us 23 bits of precision;
136      *  the top bit is the sign. */
137     public static final int COMPLEX_MANTISSA_MASK = 0xffffff;
138 
139     /* ------------------------------------------------------------ */
140 
141     /**
142      * If {@link #density} is equal to this value, then the density should be
143      * treated as the system‘s default density value: {@link DisplayMetrics#DENSITY_DEFAULT}.
144      */
145     public static final int DENSITY_DEFAULT = 0;
146 
147     /**
148      * If {@link #density} is equal to this value, then there is no density
149      * associated with the resource and it should not be scaled.
150      */
151     public static final int DENSITY_NONE = 0xffff;
152 
153     /* ------------------------------------------------------------ */
154 
155     /** The type held by this value, as defined by the constants here.
156      *  This tells you how to interpret the other fields in the object. */
157     public int type;
158 
159     /** If the value holds a string, this is it. */
160     public CharSequence string;
161 
162     /** Basic data in the value, interpreted according to {@link #type} */
163     public int data;
164 
165     /** Additional information about where the value came from; only
166      *  set for strings. */
167     public int assetCookie;
168 
169     /** If Value came from a resource, this holds the corresponding resource id. */
170     public int resourceId;
171 
172     /** If Value came from a resource, these are the configurations for which
173      *  its contents can change. */
174     public int changingConfigurations = -1;
175 
176     /**
177      * If the Value came from a resource, this holds the corresponding pixel density.
178      * */
179     public int density;
180 
181     /* ------------------------------------------------------------ */
182 
183     /** Return the data for this value as a float.  Only use for values
184      *  whose type is {@link #TYPE_FLOAT}. */
185     public final float getFloat() {
186         return Float.intBitsToFloat(data);
187     }
188 
189     private static final float MANTISSA_MULT =
190         1.0f / (1<<TypedValue.COMPLEX_MANTISSA_SHIFT);
191     private static final float[] RADIX_MULTS = new float[] {
192         1.0f*MANTISSA_MULT, 1.0f/(1<<7)*MANTISSA_MULT,
193         1.0f/(1<<15)*MANTISSA_MULT, 1.0f/(1<<23)*MANTISSA_MULT
194     };
195 
196     /**
197      * Retrieve the base value from a complex data integer.  This uses the 
198      * {@link #COMPLEX_MANTISSA_MASK} and {@link #COMPLEX_RADIX_MASK} fields of 
199      * the data to compute a floating point representation of the number they 
200      * describe.  The units are ignored. 
201      *  
202      * @param complex A complex data value.
203      * 
204      * @return A floating point value corresponding to the complex data.
205      */
206     public static float complexToFloat(int complex)
207     {
208         return (complex&(TypedValue.COMPLEX_MANTISSA_MASK
209                    <<TypedValue.COMPLEX_MANTISSA_SHIFT))
210             * RADIX_MULTS[(complex>>TypedValue.COMPLEX_RADIX_SHIFT)
211                             & TypedValue.COMPLEX_RADIX_MASK];
212     }
213 
214     /**
215      * Converts a complex data value holding a dimension to its final floating 
216      * point value. The given <var>data</var> must be structured as a 
217      * {@link #TYPE_DIMENSION}.
218      *  
219      * @param data A complex data value holding a unit, magnitude, and 
220      *             mantissa.
221      * @param metrics Current display metrics to use in the conversion -- 
222      *                supplies display density and scaling information.
223      * 
224      * @return The complex floating point value multiplied by the appropriate 
225      * metrics depending on its unit. 
226      */
227     public static float complexToDimension(int data, DisplayMetrics metrics)
228     {
229         return applyDimension(
230             (data>>COMPLEX_UNIT_SHIFT)&COMPLEX_UNIT_MASK,
231             complexToFloat(data),
232             metrics);
233     }
234 
235     /**
236      * Converts a complex data value holding a dimension to its final value
237      * as an integer pixel offset.  This is the same as
238      * {@link #complexToDimension}, except the raw floating point value is
239      * truncated to an integer (pixel) value.
240      * The given <var>data</var> must be structured as a 
241      * {@link #TYPE_DIMENSION}.
242      *  
243      * @param data A complex data value holding a unit, magnitude, and 
244      *             mantissa.
245      * @param metrics Current display metrics to use in the conversion -- 
246      *                supplies display density and scaling information.
247      * 
248      * @return The number of pixels specified by the data and its desired
249      * multiplier and units.
250      */
251     public static int complexToDimensionPixelOffset(int data,
252             DisplayMetrics metrics)
253     {
254         return (int)applyDimension(
255                 (data>>COMPLEX_UNIT_SHIFT)&COMPLEX_UNIT_MASK,
256                 complexToFloat(data),
257                 metrics);
258     }
259 
260     /**
261      * Converts a complex data value holding a dimension to its final value
262      * as an integer pixel size.  This is the same as
263      * {@link #complexToDimension}, except the raw floating point value is
264      * converted to an integer (pixel) value for use as a size.  A size
265      * conversion involves rounding the base value, and ensuring that a
266      * non-zero base value is at least one pixel in size.
267      * The given <var>data</var> must be structured as a 
268      * {@link #TYPE_DIMENSION}.
269      *  
270      * @param data A complex data value holding a unit, magnitude, and 
271      *             mantissa.
272      * @param metrics Current display metrics to use in the conversion -- 
273      *                supplies display density and scaling information.
274      * 
275      * @return The number of pixels specified by the data and its desired
276      * multiplier and units.
277      */
278     public static int complexToDimensionPixelSize(int data,
279             DisplayMetrics metrics)
280     {
281         final float value = complexToFloat(data);
282         final float f = applyDimension(
283                 (data>>COMPLEX_UNIT_SHIFT)&COMPLEX_UNIT_MASK,
284                 value,
285                 metrics);
286         final int res = (int)(f+0.5f);
287         if (res != 0) return res;
288         if (value == 0) return 0;
289         if (value > 0) return 1;
290         return -1;
291     }
292 
293     public static float complexToDimensionNoisy(int data, DisplayMetrics metrics)
294     {
295         float res = complexToDimension(data, metrics);
296         System.out.println(
297             "Dimension (0x" + ((data>>TypedValue.COMPLEX_MANTISSA_SHIFT)
298                                & TypedValue.COMPLEX_MANTISSA_MASK)
299             + "*" + (RADIX_MULTS[(data>>TypedValue.COMPLEX_RADIX_SHIFT)
300                                 & TypedValue.COMPLEX_RADIX_MASK] / MANTISSA_MULT)
301             + ")" + DIMENSION_UNIT_STRS[(data>>COMPLEX_UNIT_SHIFT)
302                                 & COMPLEX_UNIT_MASK]
303             + " = " + res);
304         return res;
305     }
306 
307     /**
308      * Converts an unpacked complex data value holding a dimension to its final floating 
309      * point value. The two parameters <var>unit</var> and <var>value</var>
310      * are as in {@link #TYPE_DIMENSION}.
311      *  
312      * @param unit The unit to convert from.
313      * @param value The value to apply the unit to.
314      * @param metrics Current display metrics to use in the conversion -- 
315      *                supplies display density and scaling information.
316      * 
317      * @return The complex floating point value multiplied by the appropriate 
318      * metrics depending on its unit. 
319      */
320     public static float applyDimension(int unit, float value,
321                                        DisplayMetrics metrics)
322     {
323         switch (unit) {
324         case COMPLEX_UNIT_PX:
325             return value;
326         case COMPLEX_UNIT_DIP:
327             return value * metrics.density;
328         case COMPLEX_UNIT_SP:
329             return value * metrics.scaledDensity;
330         case COMPLEX_UNIT_PT:
331             return value * metrics.xdpi * (1.0f/72);
332         case COMPLEX_UNIT_IN:
333             return value * metrics.xdpi;
334         case COMPLEX_UNIT_MM:
335             return value * metrics.xdpi * (1.0f/25.4f);
336         }
337         return 0;
338     }
339 
340     /**
341      * Return the data for this value as a dimension.  Only use for values 
342      * whose type is {@link #TYPE_DIMENSION}. 
343      * 
344      * @param metrics Current display metrics to use in the conversion -- 
345      *                supplies display density and scaling information.
346      * 
347      * @return The complex floating point value multiplied by the appropriate 
348      * metrics depending on its unit. 
349      */
350     public float getDimension(DisplayMetrics metrics)
351     {
352         return complexToDimension(data, metrics);
353     }
354 
355     /**
356      * Converts a complex data value holding a fraction to its final floating 
357      * point value. The given <var>data</var> must be structured as a 
358      * {@link #TYPE_FRACTION}.
359      * 
360      * @param data A complex data value holding a unit, magnitude, and 
361      *             mantissa.
362      * @param base The base value of this fraction.  In other words, a 
363      *             standard fraction is multiplied by this value.
364      * @param pbase The parent base value of this fraction.  In other 
365      *             words, a parent fraction (nn%p) is multiplied by this
366      *             value.
367      * 
368      * @return The complex floating point value multiplied by the appropriate 
369      * base value depending on its unit. 
370      */
371     public static float complexToFraction(int data, float base, float pbase)
372     {
373         switch ((data>>COMPLEX_UNIT_SHIFT)&COMPLEX_UNIT_MASK) {
374         case COMPLEX_UNIT_FRACTION:
375             return complexToFloat(data) * base;
376         case COMPLEX_UNIT_FRACTION_PARENT:
377             return complexToFloat(data) * pbase;
378         }
379         return 0;
380     }
381 
382     /**
383      * Return the data for this value as a fraction.  Only use for values whose 
384      * type is {@link #TYPE_FRACTION}. 
385      * 
386      * @param base The base value of this fraction.  In other words, a 
387      *             standard fraction is multiplied by this value.
388      * @param pbase The parent base value of this fraction.  In other 
389      *             words, a parent fraction (nn%p) is multiplied by this
390      *             value.
391      * 
392      * @return The complex floating point value multiplied by the appropriate 
393      * base value depending on its unit. 
394      */
395     public float getFraction(float base, float pbase)
396     {
397         return complexToFraction(data, base, pbase);
398     }
399 
400     /**
401      * Regardless of the actual type of the value, try to convert it to a
402      * string value.  For example, a color type will be converted to a
403      * string of the form #aarrggbb.
404      * 
405      * @return CharSequence The coerced string value.  If the value is
406      *         null or the type is not known, null is returned.
407      */
408     public final CharSequence coerceToString()
409     {
410         int t = type;
411         if (t == TYPE_STRING) {
412             return string;
413         }
414         return coerceToString(t, data);
415     }
416 
417     private static final String[] DIMENSION_UNIT_STRS = new String[] {
418         "px", "dip", "sp", "pt", "in", "mm"
419     };
420     private static final String[] FRACTION_UNIT_STRS = new String[] {
421         "%", "%p"
422     };
423 
424     /**
425      * Perform type conversion as per {@link #coerceToString()} on an
426      * explicitly supplied type and data.
427      * 
428      * @param type The data type identifier.
429      * @param data The data value.
430      * 
431      * @return String The coerced string value.  If the value is
432      *         null or the type is not known, null is returned.
433      */
434     public static final String coerceToString(int type, int data)
435     {
436         switch (type) {
437         case TYPE_NULL:
438             return null;
439         case TYPE_REFERENCE:
440             return "@" + data;
441         case TYPE_ATTRIBUTE:
442             return "?" + data;
443         case TYPE_FLOAT:
444             return Float.toString(Float.intBitsToFloat(data));
445         case TYPE_DIMENSION:
446             return Float.toString(complexToFloat(data)) + DIMENSION_UNIT_STRS[
447                 (data>>COMPLEX_UNIT_SHIFT)&COMPLEX_UNIT_MASK];
448         case TYPE_FRACTION:
449             return Float.toString(complexToFloat(data)*100) + FRACTION_UNIT_STRS[
450                 (data>>COMPLEX_UNIT_SHIFT)&COMPLEX_UNIT_MASK];
451         case TYPE_INT_HEX:
452             return "0x" + Integer.toHexString(data);
453         case TYPE_INT_BOOLEAN:
454             return data != 0 ? "true" : "false";
455         }
456 
457         if (type >= TYPE_FIRST_COLOR_INT && type <= TYPE_LAST_COLOR_INT) {
458             return "#" + Integer.toHexString(data);
459         } else if (type >= TYPE_FIRST_INT && type <= TYPE_LAST_INT) {
460             return Integer.toString(data);
461         }
462 
463         return null;
464     }
465 
466     public void setTo(TypedValue other)
467     {
468         type = other.type;
469         string = other.string;
470         data = other.data;
471         assetCookie = other.assetCookie;
472         resourceId = other.resourceId;
473         density = other.density;
474     }
475 
476     public String toString()
477     {
478         StringBuilder sb = new StringBuilder();
479         sb.append("TypedValue{t=0x").append(Integer.toHexString(type));
480         sb.append("/d=0x").append(Integer.toHexString(data));
481         if (type == TYPE_STRING) {
482             sb.append(" \"").append(string != null ? string : "<null>").append("\"");
483         }
484         if (assetCookie != 0) {
485             sb.append(" a=").append(assetCookie);
486         }
487         if (resourceId != 0) {
488             sb.append(" r=0x").append(Integer.toHexString(resourceId));
489         }
490         sb.append("}");
491         return sb.toString();
492     }
493 };
Android.util.TypedValue

 

  自定义DensityUtil类

  说明:+0.5f的原因:根据网上的说法是为了保证结果不小于0.

 1 /**
 2      * 根据手机的分辨率从 dp 的单位 转成为 px(像素)
 3      */
 4     public static int dip2px(Context context, float dpValue) {
 5         final float scale = context.getResources().getDisplayMetrics().density;
 6         return (int) (dpValue * scale + 0.5f);
 7     }
 8 
 9     /**
10      * 根据手机的分辨率从 px(像素) 的单位 转成为 dp
11      */
12     public static int px2dip(Context context, float pxValue) {
13         final float scale = context.getResources().getDisplayMetrics().density;
14         return (int) (pxValue / scale + 0.5f);
15     }

 

Android 厘米转dip、px转dip 地图比例尺长度计算

标签:

原文地址:http://www.cnblogs.com/junqinghaha/p/4305266.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!