Формула px до dp, dp до px android

Я намагаюся обчислити змінну кількість пікселів до щільних незалежних пікселів і навпаки.

Ця формула (px to dp): dp = (int)(px / (displayMetrics.densityDpi / 160));не працює на малих пристроях, оскільки ділиться на нуль.

Це моя формула dp to px:

px = (int)(dp * (displayMetrics.densityDpi / 160));

Може хтось дасть мені вказівки?

Примітка. Наведене вище широко використовуване рішення засноване на displayMetrics.density. Однак, документи пояснюють, що це значення - це округлене значення, яке використовується із екранами "відра". Напр. на моєму Nexus 10 він повертає 2, де реальне значення буде 298dpi (реальне) / 160dpi (за замовчуванням) = 1,88625.

Залежно від ваших вимог, вам може знадобитися точне перетворення, яке можна досягти так:

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

Перетворити dp в піксель:

public int dpToPx(int dp) {
    DisplayMetrics displayMetrics = getContext().getResources().getDisplayMetrics();
    return Math.round(dp * (displayMetrics.xdpi / DisplayMetrics.DENSITY_DEFAULT));     
}

Перетворити піксель у dp:

public int pxToDp(int px) {
    DisplayMetrics displayMetrics = getContext().getResources().getDisplayMetrics();
    return Math.round(px / (displayMetrics.xdpi / DisplayMetrics.DENSITY_DEFAULT));
}

Зауважте, що є властивості xdpi та ydpi, ви можете розрізнити, але я не можу уявити здоровий дисплей, де ці значення сильно відрізняються.

Я вирішив свою проблему за допомогою наступних формул. Нехай інші люди отримують від цього користь.

dp до px:

displayMetrics = context.getResources().getDisplayMetrics();
return (int)((dp * displayMetrics.density) + 0.5);

px до dp:

displayMetrics = context.getResources().getDisplayMetrics();
return (int) ((px/displayMetrics.density)+0.5);

px до dp:

int valueInpx = ...;
int valueInDp= (int) TypedValue.applyDimension(
            TypedValue.COMPLEX_UNIT_DIP, valueInpx , getResources()
                .getDisplayMetrics());

Ефективний спосіб

DP до Pixel:

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

Піксель до DP:

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

Сподіваюся, що це вам допоможе.

Просто зателефонуйте getResources().getDimensionPixelSize(R.dimen.your_dimension)для перетворення з dpодиниць у пікселі

Використовуйте цю функцію

private int dp2px(int dp) {
    return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, getResources().getDisplayMetrics());
}

px = dp * (dpi / 160)

dp = px * (160 / dpi)

У більшості випадків функції перетворення викликаються часто. Ми можемо оптимізувати його, додавши запам'ятовування. Отже, він не обчислює кожен раз, коли функція викликається.

Давайте оголосимо HashMap, який буде зберігати обчислені значення.

private static Map<Float, Float> pxCache = new HashMap<>();

Функція, яка обчислює значення пікселів:

public static float calculateDpToPixel(float dp, Context context) {

        Resources resources = context.getResources();
        DisplayMetrics metrics = resources.getDisplayMetrics();
        float px = dp * (metrics.densityDpi / 160f);
        return px;

    }

Функція запам'ятовування, яка повертає значення з HashMap і підтримує запис попередніх значень.

Пам'ять може бути реалізована різними способами на Java. Для Java 7 :

public static float convertDpToPixel(float dp, final Context context) {

        Float f = pxCache.get(dp);
        if (f == null) {
            synchronized (pxCache) {
                f = calculateDpToPixel(dp, context);
                pxCache.put(dp, f);
            }

        }

        return f;
    }

Java 8 підтримує функцію Lambda :

public static float convertDpToPixel(float dp, final Context context) {

        pxCache.computeIfAbsent(dp, y ->calculateDpToPixel(dp,context));
}

Дякую.

спробуйте це http://labs.skinkers.com/content/android_dp_px_calculator/

Нижче функції функціонували для мене на різних пристроях.

Воно взято з https://gist.github.com/laaptu/7867851

public static float convertPixelsToDp(float px){
    DisplayMetrics metrics = Resources.getSystem().getDisplayMetrics();
    float dp = px / (metrics.densityDpi / 160f);
    return Math.round(dp);
}

public static float convertDpToPixel(float dp){
    DisplayMetrics metrics = Resources.getSystem().getDisplayMetrics();
    float px = dp * (metrics.densityDpi / 160f);
    return Math.round(px);
}

Ви можете використовувати [DisplayMatrics][1]та визначати щільність екрана. Щось на зразок цього:

int pixelsValue = 5; // margin in pixels
float d = context.getResources().getDisplayMetrics().density;
int margin = (int)(pixelsValue * d);

Як я пам’ятаю, краще використовувати підлогу для зміщення, а округлення для ширини.

Якщо ви шукаєте онлайн-калькулятор для перетворення DP, SP, дюймів, міліметрів, точок або пікселів в та між собою при різній щільності екрана, це найповніший інструмент, про який я знаю .

// для отримання в перерахунку на десяткові числа / Float

public static float convertPixelsToDp(float px, Context context) {

    Resources resources = context.getResources();
    DisplayMetrics metrics = resources.getDisplayMetrics();
    float dp = px / (metrics.densityDpi / 160f);
    return Math.round(dp);
}



public static float convertDpToPixel(float dp, Context context) {
    DisplayMetrics metrics = Resources.getSystem().getDisplayMetrics();
    float px = dp * (metrics.densityDpi / 160f);
    return Math.round(px);
}


// for  getting in terms of Integer

private int convertPxToDp(int px, Context context) {
    Resources resources = context.getResources();
    return Math.round(px / (resources.getDisplayMetrics().xdpi / DisplayMetrics.DENSITY_DEFAULT));
}


private int convertDpToPx(int dp, Context context) {
    Resources resources = context.getResources();

    return Math.round(dp * (resources.getDisplayMetrics().xdpi / DisplayMetrics.DENSITY_DEFAULT));

}

________________________________________________________________________________

public static float convertPixelsToDp(float px){
    DisplayMetrics metrics = Resources.getSystem().getDisplayMetrics();
    float dp = px / (metrics.densityDpi / 160f);
    return Math.round(dp);
}

public static float convertDpToPixel(float dp){
    DisplayMetrics metrics = Resources.getSystem().getDisplayMetrics();
    float px = dp * (metrics.densityDpi / 160f);
    return Math.round(px);
}


private int convertDpToPx(int dp){
    return Math.round(dp*(getResources().getDisplayMetrics().xdpi/DisplayMetrics.DENSITY_DEFAULT));

}

private int convertPxToDp(int px){
    return Math.round(px/(Resources.getSystem().getDisplayMetrics().xdpi/DisplayMetrics.DENSITY_DEFAULT));
}

Скористайтеся цими розширеннями Kotlin:

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

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

Не соромтеся використовувати цей метод, я написав:

int dpToPx(int dp)
{
    return (int) (dp * getResources().getDisplayMetrics().density + 0.5f);
}

Відповідь, прийнята вище, не є повністю точною. Відповідно до інформації, отриманої при перевірці вихідного коду Android:

Resources.getDimension()та getDimensionPixelOffset()/ getDimensionPixelSize()відрізняються лише тим, що перший повертає, floatтоді як останні два повертають те саме значення, округлене до intвідповідного. Для всіх них повернене значення знаходиться в необроблених пікселях.

Усі три функції реалізуються за допомогою виклику Resources.getValue()та перетворення, отриманих таким чином TypedValueпри виклику TypedValue.complexToDimension(), TypedValue.complexToDimensionPixelOffset()і TypedValue.complexToDimensionPixelSize(), відповідно.

Тому, якщо ви хочете отримати "необроблене" значення разом з одиницею, зазначеною у джерелі XML, зателефонуйте Resources.getValue()та використовуйте методи TypedValueкласу.

за допомогою інших відповідей я написав цю функцію.

public static int convertToPixels(Context context, int nDP)
{
        final float conversionScale = context.getResources().getDisplayMetrics().density; 
        return (int) ((nDP * conversionScale) + 0.5f) ;
}

Ось інший спосіб зробити це за допомогою розширень kotlin:

val Int.dpToPx: Int
    get() = Math.round(this * Resources.getSystem().displayMetrics.density)

val Int.pxToDp: Int
    get() = Math.round(this / Resources.getSystem().displayMetrics.density)

і тоді його можна використовувати так з будь-якого місця

12.dpToPx

244.pxToDp

DisplayMetrics displayMetrics = contaxt.getResources()
            .getDisplayMetrics();

    int densityDpi = (int) (displayMetrics.density * 160f);
    int ratio = (densityDpi / DisplayMetrics.DENSITY_DEFAULT);
    int px;
    if (ratio == 0) {
        px = dp;
    } else {
        px = Math.round(dp * ratio);

    }

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

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

px = dp * dpi / 160
dp = px * 160 / dpi

5 * 120 = 600 / 160 = 3

замість

5 * (120 / 160 = 0) = 0

якщо ви хочете округлий результат, зробіть це

px = (10 * dp * dpi / 160 + 5) / 10
dp = (10 * px * 160 / dpi + 5) / 10

10 * 5 * 120 = 6000 / 160 = 37 + 5 = 42 / 10 = 4