Android Paint:.measureText() vs getTextBounds()

Mi experiencia con esto es que getTextBounds devolverá ese recto de límite mínimo absoluto que encapsula el texto, no necesariamente el ancho medido utilizado al renderizar. También quiero decir que measureText asume una línea.

Para obtener resultados de medición precisos, debe usar StaticLayout para renderizar el texto y extraer las mediciones.

Por ejemplo:

String 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 respuesta de los ratones es genial... Y aquí está la descripción del verdadero problema:

La respuesta corta y simple es que Paint.getTextBounds(String text, int start, int end, Rect bounds) devuelve Rect que no comienza en (0,0). Es decir, para obtener el ancho real del texto que se establecerá llamando a Canvas.drawText(String text, float x, float y, Paint paint) con el mismo objeto Paint de getTextBounds() debe agregar la posición izquierda de Rect. Algo así:

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

Observe esto bounds.left - esta es la clave del problema.

De esta manera usted recibirá la misma anchura de texto, que recibirías usando Canvas.drawText().

Y la misma función debería ser para obtener height del texto:

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

P. S.: No probé este código exacto, pero probé la concepción.

Se da una explicación mucho más detallada en esta respuesta.

Perdón por responder de nuevo a esa pregunta... Necesitaba incrustar la imagen.

Creo que los resultados que @mice encontró son erróneos. Las observaciones pueden ser correctas para el tamaño de fuente de 60, pero se vuelven mucho más diferentes cuando el texto es más pequeño. Eg. 10px. En ese caso, el texto se dibuja realmente MÁS ALLÁ de los límites.

Código fuente de la captura de pantalla:

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

DESCARGO DE RESPONSABILIDAD: Esta solución no es 100% precisa en términos de determinar el ancho mínimo.

También estaba averiguando cómo medir el texto en un lienzo. Después de leer el gran post de ratones tuve algunos problemas sobre cómo medir texto multilínea. No hay una manera obvia de estas contribuciones, pero después de algunas investigaciones cam a través de la clase StaticLayout. Le permite medir texto multilínea (texto con "\n") y configurar muchas más propiedades de su texto a través de la pintura asociada.

Aquí hay un fragmento que muestra cómo medir texto multilínea:

private StaticLayout measure( TextPaint textPaint, String 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;
}

El wrapwitdh es capaz de determinar si desea limitar su texto multilínea a un cierto ancho.

Desde el StaticLayout.getWidth () solo devuelve este boundedWidth tienes que dar otro paso para obtener el ancho máximo requerido por tu texto multilínea. Usted es capaz de determinar el ancho de cada línea y el ancho máximo es el ancho de línea más alto por supuesto:

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

Hay otra forma de medir los límites del texto con precisión, primero debe obtener la ruta para la pintura y el texto actuales. En tu caso debería ser así:

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

Después de eso puedes llamar:

mPath.computeBounds(mBoundsPath, true);

En mi código siempre devuelve valores correctos y esperados. Pero, no estoy seguro de si funciona más rápido que su enfoque.

Así es como calculé las dimensiones reales para la primera letra (puede cambiar el encabezado del método para adaptarse a sus necesidades, es decir, en lugar de char[] use String):

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

Tenga en cuenta que estoy usando TextPaint en lugar de la clase Paint original.