Konwersja pikseli na dp

Stworzyłem swoją aplikację z wysokością i szerokością podaną w pikselach dla urządzenia Pantech, którego rozdzielczość wynosi 480x800.

Muszę przekonwertować wysokość i szerokość dla urządzenia G1.
Myślałem, że konwersja do dp rozwiąże problem i zapewni takie samo rozwiązanie dla obu urządzeń.

Czy jest jakiś prosty sposób na konwersję pikseli na dp?
Jakieś sugestie?

// 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);
}

Najlepiej umieścić w klasie 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 równa się

• .75włączony ldpi( 120dpi)
• 1.0włączony mdpi( 160dpi; linia bazowa)
• 1.5włączony hdpi( 240dpi)
• 2.0włączony xhdpi( 320dpi)
• 3.0włączony xxhdpi( 480dpi)
• 4.0włączony xxxhdpi( 640dpi)

Użyj tego konwertera online do zabawy z wartościami dpi.

EDYCJA: Wydaje się, że nie ma związku 1: 1 między dpiwiadrem a density. Wygląda na to, że Nexus 5Xistota xxhdpima densitywartość 2.625(zamiast 3). Przekonaj się w Metryk urządzenia .

Możesz użyć tego .. bez kontekstu

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);
}

Jak wspomniano w @Stan ... stosowanie tego podejścia może powodować problemy, jeśli system zmieni gęstość. Więc bądź tego świadomy!

Osobiście używam do tego kontekstu. To tylko kolejne podejście, którym chciałem się z tobą podzielić

Jeśli możesz użyć wymiarów XML, jest to bardzo proste!

W twoim res/values/dimens.xml:

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

Następnie w Javie:

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

Zgodnie z Android Development Guide:

px = dp * (dpi / 160)

Ale często będziesz chciał to zrobić odwrotnie, gdy otrzymasz projekt wyrażony w pikselach. Więc:

dp = px / (dpi / 160)

Jeśli korzystasz z urządzenia o rozdzielczości 240dpi, współczynnik ten wynosi 1,5 (jak podano wcześniej), więc oznacza to, że ikona 60px jest równa 40dp w aplikacji.

Bez Contexteleganckich metod statycznych:

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);
}

Dla DP to Pixel

Utwórz wartość w dimens.xml

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

Uzyskaj tę wartość pixeljako:

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

Możesz zatem użyć następującego formulatora, aby obliczyć odpowiednią liczbę pikseli na podstawie wymiaru określonego w 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);
}

Dla każdego, kto używa Kotlin:

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

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

Stosowanie:

64.toPx
32.toDp

Domyślne użycie w zestawie Android SDK: http://developer.android.com/reference/android/util/TypedValue.html

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

użycie rozszerzenia kotlin czyni go lepszym

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

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

AKTUALIZACJA:

Ponieważ displayMetricsjest częścią globalnych zasobów współdzielonych , możemy z nich korzystaćResources.getSystem()

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

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

To powinno dać ci konwersję dp na piksele:

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

To powinno dać ci konwersję pikseli do dp:

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

Kotlin

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)
}

Jawa

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);
}

Prawdopodobnie najlepszym sposobem, jeśli masz wymiar wewnątrz wartości / dimen, jest uzyskanie wymiaru bezpośrednio z metody getDimension (), zwróci ci on wymiar już przekonwertowany na wartość w pikselach.

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

Żeby to lepiej wyjaśnić,

getDimension(int resourceId) 

zwróci wymiar już przekonwertowany na piksel AS A FLOAT.

getDimensionPixelSize(int resourceId)

zwróci to samo, ale obcięte do int, więc JAKO INTEGR.

Zobacz dokumentację Androida

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());
}

gdzie zasób to context.getResources ().

lubię to:

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;
    }
}

zależy od kontekstu, zwraca wartość zmiennoprzecinkową, metodę statyczną

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

Bardziej eleganckie podejście dzięki funkcji przedłużania 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()

Stosowanie:

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);

Jeśli opracowujesz aplikację krytyczną dla wydajności, rozważ następującą zoptymalizowaną klasę:

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;
    }
}

do konwersji pikseli na dp użyj TypedValue .

Jak wspomniano w dokumentacji: Kontener na dynamicznie wpisywaną wartość danych.

i użyj metody applyDimension :

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

który konwertuje rozpakowaną złożoną wartość danych zawierającą wymiar na końcową wartość zmiennoprzecinkową, jak poniżej:

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

Mam nadzieję, że to pomaga.

Tak to dla mnie działa:

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

Możesz zrobić to samo dla szerokości.

Wiele świetnych rozwiązań powyżej. Jednak najlepszym rozwiązaniem, jakie znalazłem, jest projekt Google:

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

Powinieneś używać dp tak samo jak pikseli. To wszystko, czym są; wyświetlać niezależne piksele. Użyj tych samych liczb, które byłyby na ekranie o średniej gęstości, a rozmiar będzie magicznie poprawny na ekranie o wysokiej gęstości.

Wygląda jednak na to, że potrzebna jest opcja fill_parent w projekcie układu. Użyj fill_parent, jeśli chcesz, aby widok lub kontrolka rozszerzyły się na cały pozostały rozmiar w kontenerze nadrzędnym.

PXi DPsą różne, ale podobne.

DPto rozdzielczość, gdy uwzględnisz tylko fizyczny rozmiar ekranu. Gdy DPgo użyjesz , przeskalujesz swój układ do innych ekranów o podobnych rozmiarach i różnej pixelgęstości.

Czasami jednak tak naprawdę chcesz pixels, a kiedy zajmujesz się wymiarami w kodzie, zawsze masz do czynienia z rzeczywistymi pixels, chyba że je przekonwertujesz.

Tak więc na urządzeniu z Androidem, normalnym hdpiekranie, 800x480 is 533x320w DP(wierzę). Aby przekonwertować DPna pixels /1.5, przekonwertować z powrotem *1.5. Dotyczy to tylko jednego rozmiaru ekranu i dpizmieniałby się w zależności od projektu. Nasi artyści dają mi pixelsjednak i przechodzę do DPpowyższego 1.5równania.

Jeśli chcesz uzyskać wartości całkowite , to użycie Math.round () zaokrągli liczbę zmiennoprzecinkową do najbliższej liczby całkowitej.

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

To działa dla mnie (C #):

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

kotlin

   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
}

Jawa

   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;
}

Najlepsza odpowiedź pochodzi z samego systemu Android: użyj tej równości ...

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

(konwertuje dp na px)