Graphics.MeasureCharacterRanges дает неправильные вычисления размера

У меня похожая проблема. Я хочу знать, насколько большим будет текст, который я рисую, и где он будет ИМЕННО. У меня не было проблемы с разрывом строки, поэтому я не думаю, что смогу вам здесь помочь. У меня были те же проблемы, что и у вас со всеми доступными методами измерения, в том числе с использованием MeasureCharacterRanges, которое нормально работало для левого и правого, но совсем не для высоты и верха. (Однако игра с базовой линией может хорошо работать для некоторых редких приложений.)

В итоге я получил очень неэлегантное, неэффективное, но работающее решение, по крайней мере, для моего варианта использования. Я рисую текст на растровом изображении, проверяю биты, чтобы увидеть, где они оказались, и это мой диапазон. Поскольку я в основном рисую мелкие шрифты и короткие строки, для меня это было достаточно быстро (особенно с добавленной мною мемоизацией). Возможно, это не совсем то, что вам нужно, но, может быть, это все равно приведет вас к правильному пути.

Обратите внимание, что на данный момент требуется компиляция проекта, чтобы разрешить использование небезопасного кода, поскольку я пытаюсь выжать из него максимум эффективности, но это ограничение можно снять, если вы захотите. Кроме того, это не так потокобезопасно, как могло бы быть прямо сейчас, вы можете легко добавить это, если вам это нужно.

Dictionary<Tuple<string, Font, Brush>, Rectangle> cachedTextBounds = new Dictionary<Tuple<string, Font, Brush>, Rectangle>();
/// <summary>
/// Determines bounds of some text by actually drawing the text to a bitmap and
/// reading the bits to see where it ended up.  Bounds assume you draw at 0, 0.  If
/// drawing elsewhere, you can easily offset the resulting rectangle appropriately.
/// </summary>
/// <param name="text">The text to be drawn</param>
/// <param name="font">The font to use when drawing the text</param>
/// <param name="brush">The brush to be used when drawing the text</param>
/// <returns>The bounding rectangle of the rendered text</returns>
private unsafe Rectangle RenderedTextBounds(string text, Font font, Brush brush) {

  // First check memoization
  Tuple<string, Font, Brush> t = new Tuple<string, Font, Brush>(text, font, brush);
  try {
    return cachedTextBounds[t];
  }
  catch(KeyNotFoundException) {
    // not cached
  }

  // Draw the string on a bitmap
  Rectangle bounds = new Rectangle();
  Size approxSize = TextRenderer.MeasureText(text, font);
  using(Bitmap bitmap = new Bitmap((int)(approxSize.Width*1.5), (int)(approxSize.Height*1.5))) {
    using(Graphics g = Graphics.FromImage(bitmap))
      g.DrawString(text, font, brush, 0, 0);
    // Unsafe LockBits code takes a bit over 10% of time compared to safe GetPixel code
    BitmapData bd = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
    byte* row = (byte*)bd.Scan0;
    // Find left, looking for first bit that has a non-zero alpha channel, so it's not clear
    for(int x = 0; x < bitmap.Width; x++)
      for(int y = 0; y < bitmap.Height; y++)
        if(((byte*)bd.Scan0)[y*bd.Stride + 4*x + 3] != 0) {
          bounds.X = x;
          goto foundX;
        }
  foundX:
    // Right
    for(int x = bitmap.Width - 1; x >= 0; x--)
      for(int y = 0; y < bitmap.Height; y++)
        if(((byte*)bd.Scan0)[y*bd.Stride + 4*x + 3] != 0) {
          bounds.Width = x - bounds.X + 1;
          goto foundWidth;
        }
  foundWidth:
    // Top
    for(int y = 0; y < bitmap.Height; y++)
      for(int x = 0; x < bitmap.Width; x++)
        if(((byte*)bd.Scan0)[y*bd.Stride + 4*x + 3] != 0) {
          bounds.Y = y;
          goto foundY;
        }
  foundY:
    // Bottom
    for(int y = bitmap.Height - 1; y >= 0; y--)
      for(int x = 0; x < bitmap.Width; x++)
        if(((byte*)bd.Scan0)[y*bd.Stride + 4*x + 3] != 0) {
          bounds.Height = y - bounds.Y + 1;
          goto foundHeight;
        }
  foundHeight:
    bitmap.UnlockBits(bd);
  }
  cachedTextBounds[t] = bounds;
  return bounds;
}

Итак, опоздал на 4 года, но этот вопрос ТОЧНО соответствовал моим симптомам, и я действительно выяснил причину.

Совершенно определенно есть ошибка в MeasureString И MeasureCharacterRanges.

Простой ответ: убедитесь, что вы разделите ограничение ширины (int width в MeasureString или свойство Size.Width в boundingRect в MeasureCharacterRanges) на 0,72. Когда вы получите свои результаты, умножьте каждое измерение на 0,72, чтобы получить РЕАЛЬНЫЙ результат.

int measureWidth = Convert.ToInt32((float)width/0.72);
SizeF measureSize = gfx.MeasureString(text, font, measureWidth, format);
float actualHeight = measureSize.Height * (float)0.72;

or

float measureWidth = width/0.72;
Region[] regions = gfx.MeasureCharacterRanges(text, font, new RectangleF(0,0,measureWidth, format);
float actualHeight = 0;
if(regions.Length>0)
{
    actualHeight = regions[0].GetBounds(gfx).Size.Height * (float)0.72;
}

Объяснение (которое я могу понять) заключается в том, что что-то, связанное с контекстом, вызывает преобразование в методах Measure (которое не запускается в методе DrawString) для inch-> point (* 72/100). Когда вы передаете ограничение ФАКТИЧЕСКОЙ ширины, оно регулирует это значение таким образом, чтобы ограничение ИЗМЕРЕННОЙ ширины было, по сути, короче, чем должно быть. Затем ваш текст переносится раньше, чем предполагалось, и поэтому вы получаете более длинный результат, чем ожидалось. К сожалению, преобразование применимо и к фактическому результату высоты, поэтому неплохо было бы «преобразовать» и это значение.

Не могли бы вы попробовать удалить следующую строку?

fmt.FormatFlags = StringFormatFlags.NoClip;

Допускаются выступающие части глифов и развернутый текст, выходящий за пределы прямоугольника форматирования. По умолчанию все части текста и глифов, выходящие за пределы прямоугольника форматирования, обрезаются.

Это лучшее, что я могу придумать для этого :(

У меня тоже были проблемы с методом MeasureCharacterRanges. Это давало мне несовместимые размеры для одной и той же строки и даже для одного и того же Graphics объекта. Затем я обнаружил, что это зависит от значения параметра layoutRect - я не понимаю, почему, на мой взгляд, это ошибка в коде .NET.

Например, если layoutRect был полностью пустым (все значения установлены на ноль), я получил правильные значения для строки «a» - размер был {Width=8.898438, Height=18.10938} с использованием шрифта Ms Sans Serif размером 12 пунктов.

Однако, когда я установил значение свойства «X» прямоугольника на нецелое число (например, 1.2), это дало мне {Width=9, Height=19}.

Поэтому я действительно думаю, что есть ошибка, когда вы используете прямоугольник макета с нецелой координатой X.

Чтобы преобразовать точки в dpi, как в разрешении экрана, вам нужно разделить на 72 и умножить на DPI, например: graphics.DpiY * text.Width / 72

Red Nightengale был действительно близок, потому что graphics.DpiY обычно 96 для разрешений экрана.