Pixel in dp konvertieren

Ich habe meine Anwendung mit der in Pixel angegebenen Höhe und Breite für ein Pantech-Gerät mit einer Auflösung erstellt 480x800.

Ich muss Höhe und Breite für ein G1-Gerät konvertieren.
Ich dachte, die Konvertierung in dp würde das Problem lösen und für beide Geräte die gleiche Lösung bieten.

Gibt es eine einfache Möglichkeit, Pixel in dp umzuwandeln?
Irgendwelche Vorschläge?

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

Am besten in eine Util.java-Klasse einfügen

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 gleich

• .75ein ldpi( 120dpi)
• 1.0ein mdpi( 160dpi; Grundlinie)
• 1.5ein hdpi( 240dpi)
• 2.0ein xhdpi( 320dpi)
• 3.0ein xxhdpi( 480dpi)
• 4.0ein xxxhdpi( 640dpi)

Verwenden Sie diesen Online-Konverter , um mit dpi-Werten herumzuspielen.

EDIT: Es scheint, dass es keine 1: 1-Beziehung zwischen dpiBucket und gibt density. Es sieht so aus, als hätte das Nexus 5XWesen xxhdpieinen densityWert von 2.625(anstelle von 3). Überzeugen Sie sich selbst in den Gerätemetriken .

Sie können dies .. ohne Kontext verwenden

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

Wie bei @Stan erwähnt, kann die Verwendung dieses Ansatzes zu Problemen führen, wenn das System die Dichte ändert. Also sei dir dessen bewusst!

Persönlich benutze ich Context, um das zu tun. Es ist nur ein weiterer Ansatz, mit dem ich Sie teilen wollte

Wenn Sie die Dimensionen XML verwenden können, ist es sehr einfach!

In Ihrem res/values/dimens.xml:

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

Dann in Ihrem Java:

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

Laut dem Android Development Guide:

px = dp * (dpi / 160)

Aber oft möchten Sie dies umgekehrt tun, wenn Sie ein Design erhalten, das in Pixel angegeben ist. Damit:

dp = px / (dpi / 160)

Wenn Sie ein 240-dpi-Gerät verwenden, beträgt dieses Verhältnis 1,5 (wie zuvor angegeben). Dies bedeutet, dass ein 60-Pixel-Symbol in der Anwendung 40 dp entspricht.

Ohne Contextelegante statische Methoden:

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

Zum DP to Pixel

Erstellen Sie einen Wert in dimens.xml

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

Erhalten Sie diesen Wert pixelals:

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

Sie können daher den folgenden Formulierer verwenden, um die richtige Anzahl von Pixeln aus einer in dp angegebenen Dimension zu berechnen

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

Für alle, die Kotlin verwenden:

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

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

Verwendungszweck:

64.toPx
32.toDp

Es gibt ein Standard-Util im Android SDK: http://developer.android.com/reference/android/util/TypedValue.html

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

Die Verwendung der Kotlin-Erweiterung macht es besser

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

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

AKTUALISIEREN:

Da dies displayMetricsTeil global geteilter Ressourcen ist , können wir es verwendenResources.getSystem()

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

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

Dies sollte Ihnen die Konvertierung von dp in Pixel geben:

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

Dies sollte Ihnen die Konvertierungspixel in dp geben:

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

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

Wenn Sie die Bemaßung innerhalb von Werten / Bemaßung haben, ist es wahrscheinlich der beste Weg, die Bemaßung direkt von der Methode getDimension () abzurufen. Sie gibt die Bemaßung zurück, die bereits in einen Pixelwert konvertiert wurde.

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

Nur um das besser zu erklären,

getDimension(int resourceId) 

gibt die Dimension zurück, die bereits in Pixel AS A FLOAT konvertiert wurde.

getDimensionPixelSize(int resourceId)

wird das gleiche zurückgeben, aber auf int abgeschnitten, also ALS INTEGER.

Siehe Android-Referenz

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

Dabei ist die Ressource context.getResources ().

so was:

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

abhängig vom Kontext, return float value, statische Methode

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

Eleganterer Ansatz mit der Erweiterungsfunktion von 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()

Verwendungszweck:

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

Wenn Sie eine leistungskritische Anwendung entwickeln, berücksichtigen Sie bitte die folgende optimierte Klasse:

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

Um Pixel in dp zu konvertieren, verwenden Sie den TypedValue .

Wie in der Dokumentation erwähnt: Container für einen dynamisch typisierten Datenwert.

und verwenden Sie die Methode applyDimension :

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

Hiermit wird ein entpackter komplexer Datenwert, der eine Dimension enthält, wie folgt in seinen endgültigen Gleitkommawert konvertiert:

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

Ich hoffe, das hilft .

So funktioniert es bei mir:

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

Sie können dasselbe für die Breite tun.

Viele großartige Lösungen oben. Die beste Lösung, die ich gefunden habe, ist jedoch Googles Design:

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

Sie sollten dp genauso verwenden wie Pixel. Das ist alles was sie sind; unabhängige Pixel anzeigen. Verwenden Sie die gleichen Zahlen wie auf einem Bildschirm mittlerer Dichte, und die Größe ist auf einem Bildschirm hoher Dichte magisch korrekt.

Es hört sich jedoch so an, als ob Sie die Option fill_parent in Ihrem Layoutdesign benötigen. Verwenden Sie fill_parent, wenn Ihre Ansicht oder Ihr Steuerelement auf die gesamte verbleibende Größe im übergeordneten Container erweitert werden soll.

PXund DPsind unterschiedlich, aber ähnlich.

DPist die Auflösung, wenn Sie nur die physische Größe des Bildschirms berücksichtigen. Wenn Sie es verwenden DP, wird Ihr Layout auf andere Bildschirme ähnlicher Größe mit unterschiedlicher pixelDichte skaliert .

Gelegentlich möchten Sie jedoch tatsächlich pixels, und wenn Sie sich mit Dimensionen im Code befassen, haben Sie es immer mit real zu tun pixels, es sei denn, Sie konvertieren sie.

Also auf einem Android-Gerät, normal großer hdpiBildschirm, 800x480 is 533x320in DP(glaube ich). Zur Umwandlung DPin pixels /1.5, zu konvertieren zurück *1.5. Dies gilt nur für die eine Bildschirmgröße und dpiwürde sich je nach Design ändern. Unsere Künstler geben mirpixels aber und ich konvertiere DPmit der obigen 1.5Gleichung.

Wenn Sie Integer- Werte möchten, wird der Float mit Math.round () auf die nächste Ganzzahl gerundet.

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

Die beste Antwort kommt vom Android-Framework selbst: Verwenden Sie einfach diese Gleichheit ...

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

(konvertiert dp in px)

Das funktioniert für mich (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
}

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