android convert - Qual è la differenza tra "px", "dip", "dp" e "sp"?




15 Answers

Dalla documentazione per gli sviluppatori Android :

  1. px
    Pixel : corrisponde ai pixel effettivi sullo schermo.

  2. nel
    Pollici - in base alle dimensioni fisiche dello schermo.
    1 pollice = 2,54 centimetri

  3. mm
    Millimetri - in base alle dimensioni fisiche dello schermo.

  4. pt
    Punti : 1/72 di pollice in base alle dimensioni fisiche dello schermo.

  5. dp o dip
    Pixel indipendenti dalla densità : un'unità astratta basata sulla densità fisica dello schermo. Queste unità sono relative a uno schermo da 160 dpi, quindi un dp è un pixel su uno schermo da 160 dpi. Il rapporto tra dp-to-pixel cambierà con la densità dello schermo, ma non necessariamente in proporzione diretta. Nota: il compilatore accetta sia "dip" che "dp", sebbene "dp" sia più coerente con "sp".

  6. sp
    Scala - Pixel indipendenti: è come l'unità dp, ma è anche ridimensionata dalla preferenza della dimensione del carattere dell'utente. Si consiglia di utilizzare questa unità quando si specificano le dimensioni dei caratteri, in modo che vengano regolate sia per la densità dello schermo che per le preferenze dell'utente.

Dalla comprensione dell'indipendenza dalla densità in Android :

+----------------+----------------+---------------+-------------------------------+
| Density Bucket | Screen Density | Physical Size | Pixel Size                    | 
+----------------+----------------+---------------+-------------------------------+
| ldpi           | 120 dpi        | 0.5 x 0.5 in  | 0.5 in * 120 dpi = 60x60 px   | 
+----------------+----------------+---------------+-------------------------------+
| mdpi           | 160 dpi        | 0.5 x 0.5 in  | 0.5 in * 160 dpi = 80x80 px   | 
+----------------+----------------+---------------+-------------------------------+
| hdpi           | 240 dpi        | 0.5 x 0.5 in  | 0.5 in * 240 dpi = 120x120 px | 
+----------------+----------------+---------------+-------------------------------+
| xhdpi          | 320 dpi        | 0.5 x 0.5 in  | 0.5 in * 320 dpi = 160x160 px | 
+----------------+----------------+---------------+-------------------------------+
| xxhdpi         | 480 dpi        | 0.5 x 0.5 in  | 0.5 in * 480 dpi = 240x240 px | 
+----------------+----------------+---------------+-------------------------------+
| xxxhdpi        | 640 dpi        | 0.5 x 0.5 in  | 0.5 in * 640 dpi = 320x320 px | 
+----------------+----------------+---------------+-------------------------------+
+---------+-------------+---------------+-------------+--------------------+
| Unit    | Description | Units Per     | Density     | Same Physical Size | 
|         |             | Physical Inch | Independent | On Every Screen    | 
+---------+-------------+---------------+-------------+--------------------+
| px      | Pixels      | Varies        | No          | No                 | 
+---------+-------------+---------------+-------------+--------------------+
| in      | Inches      | 1             | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| mm      | Millimeters | 25.4          | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| pt      | Points      | 72            | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| dp      | Density     | ~160          | Yes         | No                 | 
|         | Independent |               |             |                    | 
|         | Pixels      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+
| sp      | Scale       | ~160          | Yes         | No                 | 
|         | Independent |               |             |                    | 
|         | Pixels      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+

Ulteriori informazioni possono essere trovate nella documentazione di Google Design .

Per calcolare le dimensioni sul dispositivo reale, è possibile utilizzare this app.

36 to

Qual è la differenza tra le unità di misura Android?

  • px
  • tuffo
  • dp
  • sp



Elaborerò ulteriori informazioni su come esattamente convertire dp in px:

  • Se si esegue su un dispositivo mdpi, un'immagine di 150 x 150 px occuperà 150 * 150 dp di spazio sullo schermo.
  • Se si esegue su un dispositivo HDPI, un'immagine di 150 x 150 px occuperà 100 * 100 dp di spazio sullo schermo.
  • Se si esegue su un dispositivo xhdpi, un'immagine di 150x150 px occuperà 75 * 75 dp di spazio sullo schermo.

Al contrario: per esempio, vuoi aggiungere un'immagine alla tua applicazione e ti serve per riempire un controllo da 100 * 100 dp . Dovrai creare immagini di dimensioni diverse per le dimensioni dello schermo supportate:

  • 100 * 100 px per mdpi
  • 150 * 150 px per hdpi
  • 200 * 200 px per xhdpi



Inoltre dovresti avere una chiara comprensione dei seguenti concetti:

Dimensione dello schermo:

Dimensione fisica effettiva, misurata come diagonale dello schermo. Per semplicità, Android raggruppa tutte le dimensioni effettive dello schermo in quattro dimensioni generalizzate: piccola, normale, grande ed extra large.

Densità dello schermo:

La quantità di pixel all'interno di un'area fisica dello schermo; di solito indicato come dpi (punti per pollice). Ad esempio, uno schermo con densità "bassa" ha meno pixel all'interno di una determinata area fisica, rispetto a uno schermo con densità "normale" o "alta". Per semplicità, Android raggruppa tutte le densità dello schermo effettive in quattro densità generalizzate: bassa, media, alta e molto alta.

Orientamento:

L'orientamento dello schermo dal punto di vista dell'utente. Questo è orizzontale o verticale, il che significa che le proporzioni dello schermo sono rispettivamente ampie o alte. Si noti che non solo i dispositivi diversi operano in diversi orientamenti per impostazione predefinita, ma l'orientamento può cambiare in fase di esecuzione quando l'utente ruota il dispositivo.

Risoluzione:

Il numero totale di pixel fisici su uno schermo. Quando si aggiunge il supporto per più schermi, le applicazioni non funzionano direttamente con la risoluzione; le applicazioni dovrebbero riguardare solo le dimensioni e la densità dello schermo, come specificato dai gruppi di dimensioni e densità generalizzate.

Pixel indipendente dalla densità (dp):

Un'unità di pixel virtuale che dovresti usare quando definisci il layout dell'interfaccia utente, per esprimere le dimensioni del layout o la posizione in un modo indipendente dalla densità. Il pixel indipendente dalla densità è equivalente a un pixel fisico su uno schermo a 160 dpi, che è la densità di base assunta dal sistema per uno schermo a densità "media". In fase di esecuzione, il sistema gestisce in modo trasparente qualsiasi ridimensionamento delle unità dp, in base alle necessità, in base alla densità effettiva dello schermo in uso. La conversione delle unità dp in pixel dello schermo è semplice: px = dp * (dpi / 160). Ad esempio, su uno schermo a 240 dpi, 1 dp equivale a 1,5 pixel fisici. Dovresti sempre utilizzare le unità dp quando definisci l'interfaccia utente della tua applicazione, per garantire la corretta visualizzazione dell'interfaccia utente su schermi con densità diverse.

Riferimento: sito per sviluppatori Android




Ho calcolato la seguente formula per convertire le conversioni in dpi in dp e sp




Fonte 1

Fonte 2

Fonte 3 : (i dati della fonte 3 sono forniti di seguito)

Questi sono valori di dimensione definiti in XML. Una dimensione è specificata con un numero seguito da un'unità di misura. Ad esempio: 10px, 2in, 5sp. Le seguenti unità di misura sono supportate da Android:

dp

Pixel indipendenti dalla densità: un'unità astratta basata sulla densità fisica dello schermo. Queste unità sono relative a uno schermo da 160 dpi (punti per pollice), in cui 1 dpi è approssimativamente uguale a 1 pixel. Quando si esegue uno schermo a densità più alta, il numero di pixel utilizzati per disegnare 1dp viene ridimensionato di un fattore appropriato per il dpi dello schermo. Allo stesso modo, quando su uno schermo a densità inferiore, il numero di pixel utilizzati per 1 dp viene ridimensionato. Il rapporto tra dp-to-pixel cambierà con la densità dello schermo, ma non necessariamente in proporzione diretta. L'uso delle unità dp (invece delle unità px) è una soluzione semplice per rendere le dimensioni della vista nel layout ridimensionate correttamente per diverse densità dello schermo. In altre parole, fornisce coerenza per le dimensioni reali degli elementi dell'interfaccia utente su dispositivi diversi.

sp

Pixel indipendente dalla scala: è come l'unità dp, ma è anche ridimensionato dalla preferenza della dimensione del carattere dell'utente. Si consiglia di utilizzare questa unità quando si specificano le dimensioni dei caratteri, in modo che vengano regolate sia per la densità dello schermo sia per le preferenze dell'utente.

pt

Punti: 1/72 di pollice in base alle dimensioni fisiche dello schermo.

px

Pixel - Corrisponde ai pixel effettivi sullo schermo. Questa unità di misura non è raccomandata in quanto la rappresentazione effettiva può variare tra i vari dispositivi; ogni dispositivo può avere un numero diverso di pixel per pollice e può avere più o meno pixel totali disponibili sullo schermo.

mm

Millimetri - In base alle dimensioni fisiche dello schermo.

nel

Pollici - In base alle dimensioni fisiche dello schermo.

Nota: una dimensione è una risorsa semplice a cui viene fatto riferimento utilizzando il valore fornito nell'attributo nome (non il nome del file XML). Pertanto, è possibile combinare risorse di dimensione con altre risorse semplici in un unico file XML, sotto un elemento.




px

Pixel: corrisponde ai pixel effettivi sullo schermo.

dp o dip

Pixel indipendenti dalla densità: un'unità astratta basata sulla densità fisica dello schermo. Queste unità sono relative a uno schermo da 160 dpi, quindi un dp è un pixel su uno schermo da 160 dpi.

Uso di dp:

Indipendenza dalla densità : l'applicazione raggiunge la "indipendenza dalla densità" quando conserva le dimensioni fisiche (dal punto di vista dell'utente) degli elementi dell'interfaccia utente quando vengono visualizzate su schermi con densità diverse. (cioè) L'immagine dovrebbe avere le stesse dimensioni (non ingrandite o ridotte) in diversi tipi di schermi.

sp

Pixel indipendente dalla scala: è come l'unità dp, ma è anche ridimensionato dalla preferenza della dimensione del carattere dell'utente.

http://developer.android.com/guide/topics/resources/more-resources.html#Dimension




Puoi vedere la differenza tra px e dp dall'immagine in basso, e puoi anche scoprire che px e dp non potrebbero garantire le stesse dimensioni fisiche sui diversi schermi.




Vorrei solo usare dp.

Si parla molto dell'uso di "sp" per le dimensioni dei caratteri e, mentre apprezzo il punto, non penso che sia la cosa giusta da fare dal punto di vista del design. Si può finire per rompere il tuo design se l'utente ha qualche selezione di dimensioni del font stupefacente, e l'utente finirà per incolpare l'app , e non le proprie scelte di vita.

Inoltre, se si utilizza un'app sp-font su un tablet da 160 dpi, si scoprirà che tutto si ridimensiona ... ma il font, che a confronto avrà un aspetto minuscolo. Non è una buona occhiata.

Mentre l'idea dei caratteri "sp" ha un buon cuore, è una cattiva idea. Stick con dp per tutto.




La differenza tra le unità dp e sp menzionate come " preferenza dimensione carattere utente " dalle risposte copiate dalla documentazione ufficiale può essere vista in fase di esecuzione modificando le opzioni Settings->Accessibility->Large Text .

Large Text opzione Large Text obbliga il testo a diventare 1.3 volte più grande.

private static final float LARGE_FONT_SCALE = 1.3f;

Questo potrebbe essere ovviamente dipendente dal fornitore poiché si trova in packages/apps/Settings .




  • px - un pixel, uguale a quello usato in CSS, JavaScript, ecc.
  • sp - pixel indipendenti dalla scala
  • dip - pixel indipendenti dalla densità

Normalmente lo sp viene utilizzato per le dimensioni dei caratteri, mentre per gli altri viene utilizzato dip (chiamato anche dp).




Le dimensioni dello schermo in Android sono raggruppate in categorie small , medium , large , extra large , double-extra e triple-extra . La densità dello schermo è la quantità di pixel all'interno di un'area (come pollice) dello schermo. Generalmente viene misurato in punti per pollice (dpi). La densità dello schermo è raggruppata come bassa, media, alta e altissima. La risoluzione è il numero totale di pixel nella schermata.

  • dp: Density Independent Pixel, varia in base alla densità dello schermo. Nello schermo 160 dpi, 1 dp = 1 pixel. Ad eccezione delle dimensioni del carattere, usa sempre dp.
  • dip: dip == dp. Nelle versioni precedenti di Android è stato utilizzato dip e successivamente è stato modificato in dp.
  • sp: Pixel indipendente dalla scala, ridimensionato in base alla preferenza della dimensione del carattere dell'utente. I caratteri dovrebbero usare sp.
  • px: il nostro solito pixel standard che si associa al pixel dello schermo.
  • in: pollici, rispetto alle dimensioni dello schermo fisico.
  • mm: millimetri, rispetto alle dimensioni dello schermo fisico.
  • pt: 1/72 di pollice, rispetto alle dimensioni dello schermo fisico.

Formula per la conversione tra le unità

 px = dp * (dpi / 160)

da dp a px nel dispositivo

L'esempio seguente può aiutare a capire meglio. Il ridimensionamento si verifica in base alla dimensione del bucket di 120 (ldpi), 160 (m dpi), 240 (hdpi), 320 (xhdpi), 480 (xxhdpi) e 640 (xxxhdpi). Il rapporto suggerito da Google per la progettazione è 3: 4: 6: 8: 12 per ldpi: mdpi: hdpi: xhdpi: xxhdpi

Un'immagine 150px X 150px occuperà,

  • 150 dp Spazio schermo di 150 dp in mdpi
  • Spazio dello schermo di 100 dp X 100 dp in hdpi
  • 75 dp X 75 dp spazio sullo schermo in xhdpi

È possibile utilizzare il seguente calcolatore DPI per correggere le dimensioni dell'immagine e altre dimensioni quando si desidera avere un design dell'interfaccia utente uniforme in tutti i dispositivi Android.

Calcolatrice DPI in Java

/*
Program output
LDPI: 165.0 X 60.0
MDPI: 220.0 X 80.0
HDPI: 330.0 X 120.0
XHDPI: 440.0 X 160.0
XXHDPI: 660.0 X 240.0
XXXHDPI: 880.0 X 320.0
*/


public class DPICalculator {

private final float LDPI = 120;
private final float MDPI = 160;
private final float HDPI = 240;
private final float XHDPI = 320;
private final float XXHDPI = 480;
private final float XXXHDPI = 640;    

private float forDeviceDensity;
private float width;
private float height;

public DPICalculator(float forDeviceDensity, float width, float height){
    this.forDeviceDensity = forDeviceDensity;
    this.width = width;
    this.height = height;
}

public static void main(String... args) {
    DPICalculator dpiCalculator = new DPICalculator(240,330,120);
    dpiCalculator.calculateDPI();
}


private float getPx(float dp, float value) {
    float px = dp * (value / forDeviceDensity );        
    return px;
}

private void calculateDPI() {

    float ldpiW = getPx(LDPI,width);        
    float ldpiH =  getPx(LDPI,height);
    float mdpiW = getPx(MDPI,width);        
    float mdpiH =  getPx(MDPI,height);        
    float hdpiW = getPx(HDPI,width);        
    float hdpiH =  getPx(HDPI,height);       
    float xdpiW = getPx(XHDPI,width);        
    float xdpiH =  getPx(XHDPI,height);
    float xxdpiW = getPx(XXHDPI,width);        
    float xxdpiH =  getPx(XXHDPI,height);
    float xxxdpiW = getPx(XXXHDPI,width);        
    float xxxdpiH =  getPx(XXXHDPI,height);

    System.out.println("LDPI: " + ldpiW + " X " + ldpiH);
    System.out.println("MDPI: " + mdpiW + " X " + mdpiH);
    System.out.println("HDPI: " + hdpiW + " X " + hdpiH);
    System.out.println("XHDPI: " + xdpiW + " X " + xdpiH);
    System.out.println("XXHDPI: " + xxdpiW + " X " + xxdpiH);
    System.out.println("XXXHDPI: " + xxxdpiW + " X " + xxxdpiH);        
   }
}

Ulteriori informazioni si riferiscono al seguente link.

http://javapapers.com/android/difference-between-dp-dip-sp-px-in-mm-pt-in-android/




Ho trovato un buon articolo su come progettare l'interfaccia utente di app Android per risoluzioni di schermo diverse, e mi piacerebbe lasciarlo qui solo per qualcuno che cerca in quest'area. Sì, lo so che è in qualche modo descritto nei documenti di Google (e menzionato nei post precedenti), l'ho letto ma non è stato buono per me (sì, potrei essere troppo stupido)). Non è chiaro per me come progettare layout in grado di gestire diverse dimensioni dello schermo. Odio il concetto di DP e così via, quando ho bisogno di implementare un layout di interfaccia utente "flessibile" per schermi diversi. (Ehi sviluppatori iOS - sì, hai ragione è il concetto di Storyboard).

Android non ha un cattivo concetto di interfaccia utente, ma sfiora le caratteristiche di iOS Storyboard, sfortunatamente. Progettare un'interfaccia utente flessibile in Android non è cosa facile (al meglio).

Ecco l'articolo che mi ha aiutato a capire cosa fare in Android per creare layout per schermi di diverse dimensioni:

Blog JMSTUDIO: - Decidi le dimensioni dello schermo dell'app Android

Come progettare l'interfaccia utente per le app Android per diverse dimensioni dello schermo

Per progettare un'interfaccia utente dell'app per schermi di dimensioni diverse, il nostro progetto iniziale deve soddisfare uno spazio minimo richiesto per ogni dimensione dello schermo. Android definisce una dimensione minima (in dp) per ogni tipo di schermo generalizzato. Ecco una linea guida per le dimensioni dello schermo Android. Quando otteniamo le dimensioni dello schermo in dp, non è sufficiente per noi progettare l'interfaccia utente dell'app Android. Per ogni dimensione dello schermo, abbiamo bisogno di preparare immagini grafiche e bitmap per ogni densità. Ecco una linea guida sulla densità dello schermo Android.

Per un facile calcolo, possiamo seguire il rapporto di scala 3: 4: 6: 8 tra le quattro densità generalizzate. Se creiamo un'immagine 36 × 36 pixel per dispositivo ldpi, la dimensione delle immagini della densità restante sarà 48 × 48 per mdpi, 72 × 72 per hdpi e 96 × 96 per xhdpi.

Come progettare l'interfaccia utente di app Android in Photoshop

Molti designer hanno problemi a progettare l'interfaccia utente di app Android in Photoshop o altri strumenti di progettazione grafica basati su pixel a causa dell'unità indipendente dalla densità, dp. I progettisti non sanno come mappare da dp a pixel. Google inoltre non fornisce una chiara guida alla progettazione dell'interfaccia utente Android per loro, sebbene forniscano una formula di base per la conversione di dp e pixel.

Come definizione di Android, 1pd uguale a 1px sotto il dispositivo 160 dpi (mdpi). Quindi vogliamo progettare un'app per Android per un dispositivo xlarge Android con densità mdpi, possiamo definire la nostra dimensione dell'interfaccia utente in pixel di 960 pixel in larghezza e 720px in altezza; Segui la stessa regola di mappatura, possiamo seguire le seguenti linee guida per la progettazione delle interfacce per l'interfaccia utente di Android:

AGGIUNTO : Se sei interessato anche all'interfaccia utente "flessibile", dai un'occhiata a questa libreria: un SDK Android che fornisce una nuova unità di misura: sdp (dp scalabile). Questa unità di misura scala con le dimensioni dello schermo (questo anche citato in una risposta qui, sulla SDPlibreria)

ADDED2 Google ha finalmente capito l'utilità del concetto di interfaccia utente di iOS Storeboard, e qui va ConstraintLayoutper il mondo Android: Costruire un'interfaccia utente reattiva con ConstraintLayout




1) dp: (density independent pixels)

Il numero di pixel rappresentati in una unità di dp aumenterà all'aumentare della risoluzione dello schermo (quando si hanno più punti / pixel per pollice). Al contrario su dispositivi con risoluzione inferiore, il numero di pixel rappresentati nell'unità di dp diminuirà. Poiché si tratta di un'unità relativa, deve essere confrontata con una linea di base. Questa linea di base è uno schermo da 160 dpi. Questa è l'equazione:px = dp * (dpi / 160).


2) sp: (scale independent pixels)

Questa unità viene ridimensionata in base allo schermo dpi (simile a dp) e alla preferenza della dimensione del carattere dell'utente.


3) px: (pixels)

Pixel o punti effettivi sullo schermo.


Per maggiori dettagli puoi visitare

Guida per gli sviluppatori Android> Guida per sviluppatori Android di dimensioni
> Schermate




sp: pixel indipendente dalla scala

Dovresti usarlo con i testi perché viene ridimensionato automaticamente in base alla dimensione del font che viene utilizzata dall'utente nel suo dispositivo.

px: pixel o elemento grafico è il singolo punto sullo schermo




Prima di rispondere a questa domanda fammi diminuire il numero di unità prima. Quindi ecco qua: dp o dip sono entrambi uguali e sono noti come pixel indipendenti dalla densità .

1. px - indica i pixel. I pixel sono un singolo punto, punto su uno schermo. Generalmente nell'industria mobile viene misurata in ppi (pixel per pollice). La risoluzione dello schermo è direttamente proporzionale a ppi, maggiore è il numero di pixel per pollice più alta è la risoluzione dello schermo.

Ad esempio, se si disegna un'immagine di una dimensione di 200 px * 200 px , il suo aspetto deve essere diverso su un dispositivo ad alta risoluzione rispetto a un dispositivo a bassa risoluzione. Il motivo è un'immagine di 200 px su un telefono a bassa risoluzione che apparirà più grande rispetto a un dispositivo ad alta risoluzione.

Le immagini sottostanti mostrano una risoluzione della stessa immagine su diversi telefoni -

  • Telefono con alta risoluzione dello schermo

  • Telefono con bassa risoluzione dello schermo

2. dip o dp : un'unità astratta basata sulla densità fisica dello schermo. Queste unità sono relative a uno schermo da 160 dpi, quindi un dp è un pixel su uno schermo da 160 dpi. Il rapporto tra dp-to-pixel cambierà con la densità dello schermo, ma non necessariamente in proporzione diretta. "Indipendenza dalla densità" si riferisce alla visualizzazione uniforme degli elementi dell'interfaccia utente su schermi con densità diverse.

  • Immagine che mostra 80px (immagine a sinistra) e 80 dp (immagine a destra) . Differenza di controllo

Un dp è uguale a un pixel fisico su uno schermo con una densità di 160 . Per calcolare dp:

dp = (larghezza in pixel * 160) / densità dello schermo

3. sp - indica i pixel scalabili. Generalmente sp viene utilizzato per i testi nell'interfaccia utente e sp conserva le impostazioni del carattere. Ad esempio, se un utente ha selezionato un carattere più grande di 30 sp , verrà ridimensionato automaticamente in base alle preferenze dell'utente.




Related

android android-layout user-interface dimension units-of-measurement