Android Paint: .measureText () vs .getTextBounds ()

Je mesure le texte à l’aide de Paint.getTextBounds() , car je souhaite obtenir la hauteur et la largeur du texte à afficher. Cependant, le texte réel rendu est toujours un peu plus large que le .width() de l’information Rect remplie par getTextBounds() .

À ma grande surprise, j’ai testé .measureText() et j’ai .measureText() une valeur différente (supérieure). J’ai essayé et j’ai trouvé que c’était correct.

Pourquoi signalent-ils des largeurs différentes? Comment puis-je obtenir correctement la hauteur et la largeur? Je veux dire, je peux utiliser .measureText() , mais alors je ne saurais pas si je devrais faire confiance au .height() retourné par getTextBounds() .

Comme demandé, voici le code minimal pour reproduire le problème:

 final Ssortingng someText = "Hello. I believe I'm some text!"; Paint p = new Paint(); Rect bounds = new Rect(); for (float f = 10; f < 40; f += 1f) { p.setTextSize(f); p.getTextBounds(someText, 0, someText.length(), bounds); Log.d("Test", String.format( "Size %f, measureText %f, getTextBounds %d", f, p.measureText(someText), bounds.width()) ); } 

La sortie montre que la différence est non seulement supérieure à 1 (et qu’elle n’est pas une erreur d’arrondi de dernière minute), mais semble également augmenter avec la taille (j’étais sur le sharepoint tirer plus de conclusions, mais cela peut être entièrement dépendant de la police):

 D/Test ( 607): Size 10.000000, measureText 135.000000, getTextBounds 134 D/Test ( 607): Size 11.000000, measureText 149.000000, getTextBounds 148 D/Test ( 607): Size 12.000000, measureText 156.000000, getTextBounds 155 D/Test ( 607): Size 13.000000, measureText 171.000000, getTextBounds 169 D/Test ( 607): Size 14.000000, measureText 195.000000, getTextBounds 193 D/Test ( 607): Size 15.000000, measureText 201.000000, getTextBounds 199 D/Test ( 607): Size 16.000000, measureText 211.000000, getTextBounds 210 D/Test ( 607): Size 17.000000, measureText 225.000000, getTextBounds 223 D/Test ( 607): Size 18.000000, measureText 245.000000, getTextBounds 243 D/Test ( 607): Size 19.000000, measureText 251.000000, getTextBounds 249 D/Test ( 607): Size 20.000000, measureText 269.000000, getTextBounds 267 D/Test ( 607): Size 21.000000, measureText 275.000000, getTextBounds 272 D/Test ( 607): Size 22.000000, measureText 297.000000, getTextBounds 294 D/Test ( 607): Size 23.000000, measureText 305.000000, getTextBounds 302 D/Test ( 607): Size 24.000000, measureText 319.000000, getTextBounds 316 D/Test ( 607): Size 25.000000, measureText 330.000000, getTextBounds 326 D/Test ( 607): Size 26.000000, measureText 349.000000, getTextBounds 346 D/Test ( 607): Size 27.000000, measureText 357.000000, getTextBounds 354 D/Test ( 607): Size 28.000000, measureText 369.000000, getTextBounds 365 D/Test ( 607): Size 29.000000, measureText 396.000000, getTextBounds 392 D/Test ( 607): Size 30.000000, measureText 401.000000, getTextBounds 397 D/Test ( 607): Size 31.000000, measureText 418.000000, getTextBounds 414 D/Test ( 607): Size 32.000000, measureText 423.000000, getTextBounds 418 D/Test ( 607): Size 33.000000, measureText 446.000000, getTextBounds 441 D/Test ( 607): Size 34.000000, measureText 455.000000, getTextBounds 450 D/Test ( 607): Size 35.000000, measureText 468.000000, getTextBounds 463 D/Test ( 607): Size 36.000000, measureText 474.000000, getTextBounds 469 D/Test ( 607): Size 37.000000, measureText 500.000000, getTextBounds 495 D/Test ( 607): Size 38.000000, measureText 506.000000, getTextBounds 501 D/Test ( 607): Size 39.000000, measureText 521.000000, getTextBounds 515 

Vous pouvez faire ce que j’ai fait pour inspecter un tel problème:

Étudiez le code source Android, source Paint.java, consultez les méthodes measureText et getTextBounds. Vous apprendrez que measureText appelle native_measureText et getTextBounds appelle nativeGetSsortingngBounds, qui sont des méthodes natives implémentées en C ++.

Vous continuez donc à étudier Paint.cpp, qui implémente les deux.

native_measureText -> SkPaintGlue :: measureText_CII

nativeGetSsortingngBounds -> SkPaintGlue :: getSsortingngBounds

Maintenant, votre étude vérifie où ces méthodes diffèrent. Après quelques vérifications de param, les deux appellent la fonction SkPaint :: measureText dans Skia Lib (partie d’Android), mais elles appellent toutes deux une forme surchargée.

En creusant plus loin dans Skia, je vois que les deux appels aboutissent au même calcul dans la même fonction, ne renvoyant que le résultat différemment.

Pour répondre à votre question: vos deux appels font le même calcul. La différence de résultat possible réside en fait dans le fait que getTextBounds renvoie des limites sous forme d’entier, tandis que measureText renvoie une valeur flottante.

Vous obtenez donc une erreur d’arrondi lors de la conversion de float en int, et cela se produit dans Paint.cpp dans SkPaintGlue :: doTextBounds dans l’appel à la fonction SkRect :: roundOut.

La différence entre la largeur calculée de ces deux appels peut être maximale 1.

EDIT 4 oct. 2011

Quoi de mieux que la visualisation. J’ai pris l’effort, pour explorer et pour mériter la prime 🙂

entrer la description de l'image ici

C’est la taille de police 60, en rouge le rectangle de limites , en violet le résultat de measureText.

On voit que la partie gauche des bornes commence à partir de quelques pixels, et la valeur de measureText est incrémentée de cette valeur à gauche et à droite. C’est ce qu’on appelle la valeur AdvanceX de Glyph. (J’ai découvert cela dans les sources Skia dans SkPaint.cpp)

Ainsi, le résultat du test est que measureText ajoute une valeur d’avance au texte des deux côtés, alors que getTextBounds calcule les limites minimales auxquelles le texte donné conviendra.

J’espère que ce résultat vous sera utile.

Code de test:

  protected void onDraw(Canvas canvas){ final Ssortingng s = "Hello. I'm some text!"; Paint p = new Paint(); Rect bounds = new Rect(); p.setTextSize(60); p.getTextBounds(s, 0, s.length(), bounds); float mt = p.measureText(s); int bw = bounds.width(); Log.i("LCG", Ssortingng.format( "measureText %f, getTextBounds %d (%s)", mt, bw, bounds.toShortSsortingng()) ); bounds.offset(0, -bounds.top); p.setStyle(Style.STROKE); canvas.drawColor(0xff000080); p.setColor(0xffff0000); canvas.drawRect(bounds, p); p.setColor(0xff00ff00); canvas.drawText(s, 0, bounds.bottom, p); } 

Mon expérience avec ceci est que getTextBounds renverra ce rectangle absolu minimal absolu qui encapsule le texte, pas nécessairement la largeur mesurée utilisée lors du rendu. Je veux aussi dire que measureText prend une ligne.

Afin d’obtenir des résultats de mesure précis, vous devez utiliser StaticLayout pour afficher le texte et extraire les mesures.

Par exemple:

 Ssortingng text = "text"; TextPaint textPaint = textView.getPaint(); int boundedWidth = 1000; StaticLayout layout = new StaticLayout(text, textPaint, boundedWidth , Alignment.ALIGN_NORMAL, 1.0f, 0.0f, false); int height = layout.getHeight(); 

La réponse de la souris est géniale … Et voici la description du problème réel:

La réponse simple et courte est que Paint.getTextBounds(Ssortingng text, int start, int end, Rect bounds) renvoie Rect qui ne démarre pas à (0,0) . Autrement dit, pour obtenir la largeur réelle du texte qui sera définie en appelant Canvas.drawText(Ssortingng text, float x, float y, Paint paint) avec le même object Paint de getTextBounds (), vous devez append la position gauche de Rect. Quelque chose comme ca:

 public int getTextWidth(Ssortingng text, Paint paint) { Rect bounds = new Rect(); paint.getTextBounds(text, 0, end, bounds); int width = bounds.left + bounds.width(); return width; } 

Notez que bounds.left – c’est la clé du problème.

De cette façon, vous recevrez la même largeur de texte, que vous recevriez en utilisant Canvas.drawText() .

Et la même fonction devrait être pour obtenir la height du texte:

 public int getTextHeight(Ssortingng text, Paint paint) { Rect bounds = new Rect(); paint.getTextBounds(text, 0, end, bounds); int height = bounds.bottom + bounds.height(); return height; } 

Ps: Je n’ai pas testé ce code exact, mais j’ai testé la conception.


Une explication beaucoup plus détaillée est donnée dans cette réponse.

Désolé d’avoir répondu à nouveau à cette question … J’avais besoin d’intégrer l’image.

Je pense que les résultats obtenus par les souris sont trompeurs. Les observations peuvent être correctes pour la taille de police de 60 mais elles deviennent beaucoup plus différentes lorsque le texte est plus petit. Par exemple. 10px. Dans ce cas, le texte est dessiné au-delà des limites.

entrer la description de l'image ici

Code source de la capture d’écran:

  @Override protected void onDraw( Canvas canvas ) { for( int i = 0; i < 20; i++ ) { int startSize = 10; int curSize = i + startSize; paint.setTextSize( curSize ); String text = i + startSize + " - " + TEXT_SNIPPET; Rect bounds = new Rect(); paint.getTextBounds( text, 0, text.length(), bounds ); float top = STEP_DISTANCE * i + curSize; bounds.top += top; bounds.bottom += top; canvas.drawRect( bounds, bgPaint ); canvas.drawText( text, 0, STEP_DISTANCE * i + curSize, paint ); } } 

AVERTISSEMENT: Cette solution n’est pas précise à 100% en termes de détermination de la largeur minimale.

Je cherchais également à mesurer le texte sur une canvas. Après avoir lu le bon message de souris, j’ai eu quelques problèmes sur la façon de mesurer le texte multiligne. Il n’y a pas de moyen évident de ces consortingbutions, mais après quelques recherches, je suis dans la classe StaticLayout. Il vous permet de mesurer du texte multiligne (texte avec “\ n”) et de configurer beaucoup plus de propriétés de votre texte via la peinture associée.

Voici un extrait montrant comment mesurer du texte multiligne:

 private StaticLayout measure( TextPaint textPaint, Ssortingng text, Integer wrapWidth ) { int boundedWidth = Integer.MAX_VALUE; if (wrapWidth != null && wrapWidth > 0 ) { boundedWidth = wrapWidth; } StaticLayout layout = new StaticLayout( text, textPaint, boundedWidth, Alignment.ALIGN_NORMAL, 1.0f, 0.0f, false ); return layout; } 

Le wrapwitdh est capable de déterminer si vous souhaitez limiter votre texte multiligne à une certaine largeur.

Comme StaticLayout.getWidth () ne renvoie que cette largeur limitée, vous devez effectuer une autre étape pour obtenir la largeur maximale requirejse par votre texte multiligne. Vous pouvez déterminer la largeur de chaque ligne et la largeur maximale est la largeur de ligne la plus élevée:

 private float getMaxLineWidth( StaticLayout layout ) { float maxLine = 0.0f; int lineCount = layout.getLineCount(); for( int i = 0; i < lineCount; i++ ) { if( layout.getLineWidth( 0 ) > maxLine ) { maxLine = layout.getLineWidth( 0 ); } } return maxLine; } 

Il existe un autre moyen de mesurer précisément les limites du texte. Vous devez d’abord obtenir le chemin d’access à la peinture et au texte actuels. Dans votre cas, cela devrait être comme ceci:

 p.getTextPath(someText, 0, someText.length(), 0.0f, 0.0f, mPath); 

Après cela, vous pouvez appeler:

 mPath.computeBounds(mBoundsPath, true); 

Dans mon code, il renvoie toujours des valeurs correctes et attendues. Mais vous ne savez pas si cela fonctionne plus vite que votre approche.

Voici comment j’ai calculé les dimensions réelles de la première lettre (vous pouvez modifier l’en-tête de la méthode en fonction de vos besoins, à la place de char[] use Ssortingng ):

 private void calculateTextSize(char[] text, PointF outSize) { // use measureText to calculate width float width = mPaint.measureText(text, 0, 1); // use height from getTextBounds() Rect textBounds = new Rect(); mPaint.getTextBounds(text, 0, 1, textBounds); float height = textBounds.height(); outSize.x = width; outSize.y = height; } 

Notez que j’utilise TextPaint au lieu de la classe Paint d’origine.