TextNote.Width Calculate Minimum
Hi guys,
Thank you Scott for the nice solution.
I do not understand how you get from the 3/32" font size defined in the Revit text type to the number 9 that you specify as the em-size in points of the new .NET font.
Also, vice versa, MeasureText returns the size in pixels. Why do you divide this by 86? Would that mean 86 pixels per inch? Does that depend on the Revit scale? If it is pixels, it also depends on the device, doesn't it? And the division by 12 transforms that to feet, of course.
Can you explain, please?
Thank you!
Cheers,
Jeremy
Hi again guys,
I tried to make use of your solution above and it did not seem to work for me.
I looked at ways to improve it, making it work in my context, and would like to hear your opinion on the following expanded experiment:
It performs the following steps:
- Pick a text insertion point.
- Grab the first text note type encountered.
- Convert the text note type nominal size to points, i.e. 1/72".
- Create the appropriate .NET font.
- Measure the text size in pixels in this font.
- Determine the current display horizontal dots per inch resolution.
- Use that to convert the size in pixels to inches.
- Determine the Revit view scale.
- Scale the width in inches according to that.
- Add a factor to account for imprecision, currently the experimentally determined factor 1.4.
That seems to work for me and produces the following result:
Here is the current version of the external command source code producing that result:
[Transaction( TransactionMode.Manual )]
class CmdNewTextNote : IExternalCommand
{
[DllImport( "user32.dll" )]
private static extern IntPtr GetDC( IntPtr hwnd );
[DllImport( "user32.dll" )]
private static extern Int32 ReleaseDC( IntPtr hwnd );
/// <summary>
/// Determine the current display
/// horizontal dots per inch.
/// </summary>
static float DpiX
{
get
{
Single xDpi, yDpi;
IntPtr dc = GetDC( IntPtr.Zero );
using( Graphics g = Graphics.FromHdc( dc ) )
{
xDpi = g.DpiX;
yDpi = g.DpiY;
}
if( ReleaseDC( IntPtr.Zero ) != 0 )
{
// GetLastError and handle...
}
return xDpi;
}
}
public Result Execute(
ExternalCommandData commandData,
ref string message,
ElementSet elements )
{
UIApplication uiapp = commandData.Application;
UIDocument uidoc = uiapp.ActiveUIDocument;
Document doc = uidoc.Document;
View view = doc.ActiveView;
XYZ p;
try
{
p = uidoc.Selection.PickPoint(
"Please pick text insertion point" );
}
catch( Autodesk.Revit.Exceptions.OperationCanceledException )
{
return Result.Cancelled;
}
//TextNoteType boldTextType = doc.GetElement(
// new ElementId( 1212838 ) ) as TextNoteType; // Arial 3/32" Bold
// 1 inch = 72 points
// 3/32" = 72*3/32 points =
TextNoteType textType
= new FilteredElementCollector( doc )
.OfClass( typeof( TextNoteType ) )
.FirstElement() as TextNoteType;
Debug.Print( textType.Name );
// 6 mm Arial happens to be the first text type found
// 6 mm = 6 / 25.4 inch = 72 * 6 / 25.4 points = 17 pt
Font font = new Font( "Arial", 17, FontStyle.Bold );
using( Transaction t = new Transaction( doc ) )
{
t.Start( "Create TextNote" );
string s = "The quick brown fox jumped over the lazy dog";
Size txtBox = System.Windows.Forms.TextRenderer
.MeasureText( s, font );
double w_inch = txtBox.Width / DpiX;
double v_scale = view.Scale; // ratio of true model size to paper size
Debug.Print(
"Text box width in pixels {0} = {1} inch, scale {2}",
txtBox.Width, w_inch, v_scale );
//double newWidth
// = ( (double) txtBox.Width / 86 ) / 12;
double newWidth = w_inch / 12;
newWidth = newWidth * v_scale;
newWidth *= 1.4;
TextNote txNote = doc.Create.NewTextNote(
doc.ActiveView, p, XYZ.BasisX, XYZ.BasisY,
0.1, TextAlignFlags.TEF_ALIGN_LEFT
| TextAlignFlags.TEF_ALIGN_BOTTOM, s );
txNote.TextNoteType = textType;
txNote.Width = newWidth;
t.Commit();
}
return Result.Succeeded;
}
}
I would love to hear your comments on this.
I am sure it includes at least lots of room for improvement, and potentially serious errors.
I do wonder how your simple solution presented above could work as well as you say it does.
Does it really?
Thank you!
Cheers,
Jeremy
Dear Scott and Atiefenbach,
Wow, thank you very much indeed for your valuable additional research.
That is more than I could have hoped for.
It sounds like this provides the basis for a pretty complete solution.
I implemented this partially as follows:
[Transaction( TransactionMode.Manual )]
class CmdNewTextNote : IExternalCommand
{
[DllImport( "user32.dll" )]
private static extern IntPtr GetDC( IntPtr hwnd );
[DllImport( "user32.dll" )]
private static extern Int32 ReleaseDC( IntPtr hwnd );
/// <summary>
/// Determine the current display
/// horizontal dots per inch.
/// </summary>
static float DpiX
{
get
{
Single xDpi, yDpi;
IntPtr dc = GetDC( IntPtr.Zero );
using( Graphics g = Graphics.FromHdc( dc ) )
{
xDpi = g.DpiX;
yDpi = g.DpiY;
}
if( ReleaseDC( IntPtr.Zero ) != 0 )
{
// GetLastError and handle...
}
return xDpi;
}
}
public Result Execute(
ExternalCommandData commandData,
ref string message,
ElementSet elements )
{
UIApplication uiapp = commandData.Application;
UIDocument uidoc = uiapp.ActiveUIDocument;
Document doc = uidoc.Document;
View view = doc.ActiveView;
XYZ p;
try
{
p = uidoc.Selection.PickPoint(
"Please pick text insertion point" );
}
catch( Autodesk.Revit.Exceptions.OperationCanceledException )
{
return Result.Cancelled;
}
TextNoteType textType
= new FilteredElementCollector( doc )
.OfClass( typeof( TextNoteType ) )
.FirstElement() as TextNoteType;
Debug.Print( "TextNoteType.Name = " + textType.Name );
// 6 mm Arial happens to be the first text type found
// 6 mm = 6 / 25.4 inch = 72 * 6 / 25.4 points = 17 pt.
// Nowadays, Windows does not assume that a point is
// 1/72", but moved to 1/96" instead.
float text_type_height_mm = 6;
float mm_per_inch = 25.4f;
float points_per_inch = 96; // not 72
float em_size = points_per_inch
* ( text_type_height_mm / mm_per_inch );
em_size += 2.5f;
Font font = new Font( "Arial", em_size,
FontStyle.Regular );
using( Transaction t = new Transaction( doc ) )
{
t.Start( "Create TextNote" );
string s = "The quick brown fox jumps over the lazy dog";
Size txtBox = System.Windows.Forms.TextRenderer
.MeasureText( s, font );
double w_inch = txtBox.Width / DpiX;
double v_scale = view.Scale; // ratio of true model size to paper size
Debug.Print(
"Text box width in pixels {0} = {1} inch, "
+ "view scale = {2}",
txtBox.Width, w_inch, v_scale );
double newWidth = w_inch / 12;
TextNote txNote = doc.Create.NewTextNote(
doc.ActiveView, p, XYZ.BasisX, XYZ.BasisY,
newWidth, TextAlignFlags.TEF_ALIGN_LEFT
| TextAlignFlags.TEF_ALIGN_BOTTOM, s );
txNote.TextNoteType = textType;
Debug.Print(
"NewTextNote lineWidth {0} times view scale "
+ "{1} = {2} generated TextNote.Width {3}",
Util.RealString( newWidth ),
Util.RealString( v_scale ),
Util.RealString( newWidth * v_scale ),
Util.RealString( txNote.Width ) );
// This fails.
//Debug.Assert(
// Util.IsEqual( newWidth * v_scale, txNote.Width ),
// "expected the NewTextNote lineWidth "
// + "argument to determine the resulting "
// + "text note width" );
txNote.Width = newWidth * v_scale;
t.Commit();
}
return Result.Succeeded;
}
}
Does that match your intentions and explanation, Scott?
I do not see where to obtain the "text type's Width Factor" that you mention. Where is that stored?
Furthermore, what element hosts the BuiltInParameter.LEADER_OFFSET_SHEET?
It sounds like you tested this for varous different fonts and text string samples.
Have you written some kind of test framework iterating over the available text note types, matching them with .NET fonts and trying them out with different strings?
In order to use this approach in a serious production environemnt, I would try to set up and use such a system and a corresponding unit test to verify that the chosen adjustments really do work correctly in all cases encountered.
Thank you!
Best regards,
Jeremy
Dear Scott,
Your new implementation based on Graphics.MeasureString instead of TextRenderer.MeasureText works perfectly for me:
I added this to The Building Coder samples as CmdNewTextNote and published on GitHub:
https://github.com/jeremytammik/the_building_coder_samples
Your current code is tagged as release 2015.0.114.2:
https://github.com/jeremytammik/the_building_coder_samples/releases/tag/2015.0.114.2
Thank you!
Cheers,
Jeremy
Hi Scott,
Great, thank you.
I published a summary of this interesting discussion on The Building Coder now:
http://thebuildingcoder.typepad.com/blog/2014/10/new-text-note-and-text-width-calculation.html
Cheers,
Jeremy
Sorry to revive an old discussion, but I wanted to clear some things up so that future readers of this thread aren't mislead.
First of all, the Revit DPI is 72, not 96. I confirmed this experimentally as follows:
- Inserting an image of width 332px into a revit sheet of scale 48.
- The resulting image width was 18.4444444444', so the conversion factor is (332*48)/18.4444444444 = 864
- Dividing this result by 12in/ft gives us 72DPI.
Regarding the original task at hand, placing 2 strings next to eachother, I took a slightly different approach by calculating the *exact* width of the string (in contrast to the minimum width of the note, which is notably larger than just the text), setting the note width to 110% of that (so it doesn't wrap), but then placing the next note such that it is right at the end of the exact width of the string. Thus, there is some note element overlap but the text itself lines up perfectly without an awkwardly large space afterward, as is the case with the current solution.
Here is the code I used to calculate the exact string width:
private const float REVIT_FONT_DPI = 72.0f; // NOT 96.0f;
public static double stringWidth(string textString, TextNoteType textType, bool includeBorder, int viewScale) { return stringWidthInternal(textString, textType, includeBorder, viewScale); } private static double stringWidthInternal(string textString, TextNoteType textType, bool includeBorder, int viewScale) { double stringWidthPx = systemStringWidth(textString, fontFrom(textType)); double stringWidthIn = stringWidthPx / REVIT_FONT_DPI; double stringWidthFt = stringWidthIn / 12.0; Parameter paramTextWidthScale = textType.get_Parameter(BuiltInParameter.TEXT_WIDTH_SCALE); Parameter paramBorderSize = textType.get_Parameter(BuiltInParameter.LEADER_OFFSET_SHEET); double textBorder = paramBorderSize.AsDouble(); double textWidthScale = paramTextWidthScale.AsDouble(); if (!includeBorder) textBorder = 0; double lineWidth = ((stringWidthFt * textWidthScale) + (textBorder * 2.0)) * viewScale; return lineWidth; } private static double systemStringWidth(string text, Font font) { using (Graphics g = Graphics.FromHwnd(IntPtr.Zero)) { g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.SingleBitPerPixel; StringFormat format = new System.Drawing.StringFormat(); format.FormatFlags = StringFormatFlags.MeasureTrailingSpaces; RectangleF rect = new RectangleF(0, 0, float.MaxValue / 2.0f, float.MaxValue / 2.0f); CharacterRange[] ranges = { new CharacterRange(0, text.Length) }; Region[] regions = new Region[1]; format.SetMeasurableCharacterRanges(ranges); regions = g.MeasureCharacterRanges(text, font, rect, format); if (regions.Length < 1) return 0; rect = regions[0].GetBounds(g); return rect.Width; } }
I would, however, like to thank you all for getting me on the right track.
