Перетворення пікселів у dp

Я створив свою програму з висотою та шириною, вказаною в пікселях для пристрою Pantech, роздільною здатністю якого є 480x800.

Мені потрібно перетворити висоту і ширину для пристрою G1.
Я думав, що перетворення його на dp вирішить проблему та забезпечить однакове рішення для обох пристроїв.

Чи є якийсь простий спосіб перетворити пікселі в dp?
Будь-які пропозиції?

// Converts 14 dip into its equivalent px
float dip = 14f;
Resources r = getResources();
float px = TypedValue.applyDimension(
    TypedValue.COMPLEX_UNIT_DIP,
    dip,
    r.getDisplayMetrics()
);

/**
 * This method converts dp unit to equivalent pixels, depending on device density. 
 * 
 * @param dp A value in dp (density independent pixels) unit. Which we need to convert into pixels
 * @param context Context to get resources and device specific display metrics
 * @return A float value to represent px equivalent to dp depending on device density
 */
public static float convertDpToPixel(float dp, Context context){
    return dp * ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

/**
 * This method converts device specific pixels to density independent pixels.
 * 
 * @param px A value in px (pixels) unit. Which we need to convert into db
 * @param context Context to get resources and device specific display metrics
 * @return A float value to represent dp equivalent to px value
 */
public static float convertPixelsToDp(float px, Context context){
    return px / ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

Переважно ставити в клас Util.java

public static float dpFromPx(final Context context, final float px) {
    return px / context.getResources().getDisplayMetrics().density;
}

public static float pxFromDp(final Context context, final float dp) {
    return dp * context.getResources().getDisplayMetrics().density;
}

float density = context.getResources().getDisplayMetrics().density;
float px = someDpValue * density;
float dp = somePxValue / density;

density дорівнює

• .75увімкнено ldpi( 120dpi)
• 1.0on mdpi( 160dpi; базовий рівень)
• 1.5увімкнено hdpi( 240dpi)
• 2.0увімкнено xhdpi( 320dpi)
• 3.0увімкнено xxhdpi( 480dpi)
• 4.0увімкнено xxxhdpi( 640dpi)

Використовуйте цей онлайн-конвертер, щоб пограти зі значеннями dpi.

EDIT: Здається, що між dpiвідром та ковбасом немає відносин 1: 1 density. Схоже, Nexus 5Xістота xxhdpiмає densityзначення 2.625(замість 3). Переконайтеся самі в метриці пристроїв .

Ви можете використовувати це .. без контексту

public static int pxToDp(int px) {
    return (int) (px / Resources.getSystem().getDisplayMetrics().density);
}

public static int dpToPx(int dp) {
    return (int) (dp * Resources.getSystem().getDisplayMetrics().density);
}

Як зазначав @Stan .. використання цього підходу може спричинити проблеми, якщо система змінює щільність. Тож пам’ятайте про це!

Особисто я використовую Context для цього. Я просто хотів поділитися з вами

Якщо ви можете використовувати розміри XML, це дуже просто!

У вашому res/values/dimens.xml:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <dimen name="thumbnail_height">120dp</dimen>
    ...
    ...
</resources>

Потім у вашій Java:

getResources().getDimensionPixelSize(R.dimen.thumbnail_height);

Відповідно до посібника з розробки Android:

px = dp * (dpi / 160)

Але часто вам потрібно виконати це навпаки, коли отримаєте дизайн, зазначений у пікселях. Тому:

dp = px / (dpi / 160)

Якщо ви перебуваєте на пристрої 240dpi, це співвідношення становить 1,5 (як це було зазначено раніше), тому це означає, що піктограма 60px дорівнює 40dp у додатку.

Без Contextелегантних статичних методів:

public static int dpToPx(int dp)
{
    return (int) (dp * Resources.getSystem().getDisplayMetrics().density);
}

public static int pxToDp(int px)
{
    return (int) (px / Resources.getSystem().getDisplayMetrics().density);
}

Для DP to Pixel

Створіть значення в dimens.xml

<dimen name="textSize">20dp</dimen>

Отримайте це значення у pixelвигляді:

int sizeInPixel = context.getResources().getDimensionPixelSize(R.dimen.textSize);

Отже, ви можете використовувати наступний формуляр для обчислення потрібної кількості пікселів із розмірності, зазначеної в dp

public int convertToPx(int dp) {
    // Get the screen's density scale
    final float scale = getResources().getDisplayMetrics().density;
    // Convert the dps to pixels, based on density scale
    return (int) (dp * scale + 0.5f);
}

Для всіх, хто використовує Kotlin:

val Int.toPx: Int
    get() = (this * Resources.getSystem().displayMetrics.density).toInt()

val Int.toDp: Int
    get() = (this / Resources.getSystem().displayMetrics.density).toInt()

Використання:

64.toPx
32.toDp

У програмі SDK для Android існує утиліта за замовчуванням: http://developer.android.com/reference/android/util/TypedValue.html

float resultPix = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,1,getResources().getDisplayMetrics())

використання розширення kotlin робить його кращим

fun Int.toPx(context: Context): Int = (this * context.resources.displayMetrics.density).toInt()

fun Int.toDp(context: Context): Int = (this / context.resources.displayMetrics.density).toInt()

ОНОВЛЕННЯ:

Через те, що displayMetricsє частиною глобальних спільних ресурсів , ми можемо використовуватиResources.getSystem()

fun Int.toPx(): Int = (this * Resources.getSystem().displayMetrics.density).toInt()

fun Int.toDp(): Int = (this / Resources.getSystem().displayMetrics.density).toInt()

Це повинно дати вам перетворення dp у пікселі:

public static int dpToPx(int dp)
{
    return (int) (dp * Resources.getSystem().getDisplayMetrics().density);
}

Це має дати вам пікселі конверсії в dp:

public static int pxToDp(int px)
{
    return (int) (px / Resources.getSystem().getDisplayMetrics().density);
}

Котлін

fun convertDpToPixel(dp: Float, context: Context): Float {
    return dp * (context.resources.displayMetrics.densityDpi.toFloat() / DisplayMetrics.DENSITY_DEFAULT)
}

fun convertPixelsToDp(px: Float, context: Context): Float {
    return px / (context.resources.displayMetrics.densityDpi.toFloat() / DisplayMetrics.DENSITY_DEFAULT)
}

Java

public static float convertDpToPixel(float dp, Context context) {
    return dp * ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

public static float convertPixelsToDp(float px, Context context) {
    return px / ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

Мабуть, найкращий спосіб, якщо у вас є розмір всередині значень / dimen - отримати розмірність безпосередньо методом getDimension (), він поверне вам параметр, вже перетворений у значення пікселя.

context.getResources().getDimension(R.dimen.my_dimension)

Просто, щоб краще пояснити це,

getDimension(int resourceId) 

поверне розмір, вже перетворений у піксель AS AS FLOAT.

getDimensionPixelSize(int resourceId)

поверне той самий, але усічений до int, так ЯКІЙ ІНТЕГРІЙ.

Див. Посилання на Android

public static int dp2px(Resources resource, int dp) {
    return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,   dp,resource.getDisplayMetrics());
}

  public static float px2dp(Resources resource, float px)  {
    return (float) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PX, px,resource.getDisplayMetrics());
}

де ресурсом є контекст.getResources ().

подобається це:

public class ScreenUtils {

    public static float dpToPx(Context context, float dp) {
        if (context == null) {
            return -1;
        }
        return dp * context.getResources().getDisplayMetrics().density;
    }

    public static float pxToDp(Context context, float px) {
        if (context == null) {
            return -1;
        }
        return px / context.getResources().getDisplayMetrics().density;
    }
}

залежно від контексту, зворотного поплавкового значення, статичного методу

з: https://github.com/Trinea/android-common/blob/master/src/cn/trinea/android/common/util/ScreenUtils.java#L15

Більш елегантний підхід із використанням функції розширення kotlin

/**
 * Converts dp to pixel
 */
val Int.dpToPx: Int get() = (this * Resources.getSystem().displayMetrics.density).toInt()

/**
 * Converts pixel to dp
 */
val Int.pxToDp: Int get() = (this / Resources.getSystem().displayMetrics.density).toInt()

Використання:

println("16 dp in pixel: ${16.dpToPx}")
println("16 px in dp: ${16.pxToDp}")

float scaleValue = getContext().getResources().getDisplayMetrics().density;
int pixels = (int) (dps * scaleValue + 0.5f);

Якщо ви розробляєте критичну програму для роботи, врахуйте наступний оптимізований клас:

public final class DimensionUtils {

    private static boolean isInitialised = false;
    private static float pixelsPerOneDp;

    // Suppress default constructor for noninstantiability.
    private DimensionUtils() {
        throw new AssertionError();
    }

    private static void initialise(View view) {
        pixelsPerOneDp = view.getResources().getDisplayMetrics().densityDpi / 160f;
        isInitialised = true;
    }

    public static float pxToDp(View view, float px) {
        if (!isInitialised) {
            initialise(view);
        }

        return px / pixelsPerOneDp;
    }

    public static float dpToPx(View view, float dp) {
        if (!isInitialised) {
            initialise(view);
        }

        return dp * pixelsPerOneDp;
    }
}

для перетворення пікселів у dp використовуйте TypedValue .

Як зазначено в документації: Контейнер для динамічно набраного значення даних.

і використовувати метод applyDimension :

public static float applyDimension (int unit, float value, DisplayMetrics metrics) 

який перетворює розпаковане комплексне значення даних, що містить розмір, у його кінцеве значення з плаваючою комою, наприклад:

Resources resource = getResources();
float dp = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PX, 69, resource.getDisplayMetrics());

Сподіваюся, що допомагає.

Ось як це працює для мене:

DisplayMetrics displaymetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
int  h = displaymetrics.heightPixels;
float  d = displaymetrics.density;
int heightInPixels=(int) (h/d);

Можна зробити те ж саме для ширини.

Дуже багато чудових рішень. Однак найкраще рішення, яке я знайшов, - це дизайн Google:

https://design.google.com/devices/

Ви повинні використовувати dp так само, як і пікселі. Це все, що вони є; відображення незалежних пікселів. Використовуйте ті самі цифри, що і на екрані середньої щільності, і розмір буде магічно правильним на екрані з високою щільністю.

Однак це виглядає як те, що вам потрібно - варіант fill_parent в дизайні вашого макета. Використовуйте fill_parent, коли ви хочете, щоб ваш перегляд або елемент керування розширилися на весь розмір, що залишився в батьківському контейнері.

PXі DPрізні, але схожі.

DP- це роздільна здатність, коли ви враховуєте лише фізичний розмір екрана. Під час використання DPвін буде масштабувати ваш макет на інших аналогічних за розміром екранах з різною pixelщільністю.

Іноді ви насправді хочете pixels, і коли ви маєте справу з розмірами в коді, ви завжди маєте справу з реальними pixels, якщо не перетворюєте їх.

Так що на андроїд-пристрої, звичайного розміру hdpiекрана, 800x480 is 533x320в DP(я вважаю). Перетворити DPв pixels /1.5, перетворити назад *1.5. Це лише для одного розміру екрана, і dpiвін мінятиметься залежно від дизайну. Наші артисти дають мені, pixelsхоча я перетворююсь на DPвищезгадане 1.5рівняння.

Якщо ви хочете значення Integer, то за допомогою Math.round () буде округлий поплавок до найближчого цілого числа.

public static int pxFromDp(final float dp) {
        return Math.round(dp * Resources.getSystem().getDisplayMetrics().density);
    }

Це працює для мене (C #):

int pixels = (int)((dp) * Resources.System.DisplayMetrics.Density + 0.5f);

котлін

   fun spToPx(ctx: Context, sp: Float): Float {
    return sp * ctx.resources.displayMetrics.scaledDensity
}

fun pxToDp(context: Context, px: Float): Float {
    return px / context.resources.displayMetrics.density
}

fun dpToPx(context: Context, dp: Float): Float {
    return dp * context.resources.displayMetrics.density
}

java

   public static float spToPx(Context ctx,float sp){
    return sp * ctx.getResources().getDisplayMetrics().scaledDensity;
}

public static float pxToDp(final Context context, final float px) {
    return px / context.getResources().getDisplayMetrics().density;
}

public static float dpToPx(final Context context, final float dp) {
    return dp * context.getResources().getDisplayMetrics().density;
}

Найкраща відповідь виходить із самої системи Android: просто використовуйте цю рівність ...

public static int dpToPixels(final DisplayMetrics display_metrics, final float dps) {
    final float scale = display_metrics.density;
    return (int) (dps * scale + 0.5f);
}

(перетворює dp в px)