public void EqualityTest()
{
var oneInch1 = PdfMeasurement.Inches(1.0);
var oneInch2 = PdfMeasurement.Mm(25.4);
Assert.Equal(oneInch1, oneInch2);
}
public void VerifyPageTextAndFontTest()
{
var file = new PdfFile();
var page = PdfPage.NewLetter();
var text = new PdfText("foo", new PdfFontType1(PdfFontType1Type.Helvetica), PdfMeasurement.Points(12.0), new PdfPoint(PdfMeasurement.Inches(1.0), PdfMeasurement.Inches(2.0)));
page.Items.Add(text);
file.Pages.Add(page);
AssertFileContains(file, @"
BT
/F1 12.00 Tf
72.00 144.00 Td
[(foo)] TJ
ET
");
AssertFileContains(file, @"
/Resources <</Font <</F1 5 0 R>>>>
");
AssertFileContains(file, "<</Type /Font /Subtype /Type1 /BaseFont /Helvetica>>");
text.CharacterWidth = PdfMeasurement.Points(0.25);
AssertFileContains(file, @"
BT
/F1 12.00 Tf
72.00 144.00 Td
0.25 Tc
[(foo)] TJ
ET
");
}
public void ConvertTest()
{
var oneInch = PdfMeasurement.Inches(1.0);
Assert.Equal(72.0, oneInch.AsPoints());
Assert.Equal(25.4, oneInch.ConvertTo(PdfMeasurementType.Mm).RawValue);
}
public ConverterPdfRect()
{
Left = PdfMeasurement.Zero;
Right = PdfMeasurement.Zero;
Bottom = PdfMeasurement.Zero;
Top = PdfMeasurement.Zero;
}
public DxfToPdfConverterOptions(PdfMeasurement pageWidth, PdfMeasurement pageHeight, double scale)
{
PageWidth = pageWidth;
PageHeight = pageHeight;
Scale = scale;
this.DxfSource = null;
this.PdfDestination = null;
}
public DxfToPdfConverterOptions(PdfMeasurement pageWidth, PdfMeasurement pageHeight, ConverterDxfRect?dxfSource, ConverterPdfRect pdfDestination)
{
PageWidth = pageWidth;
PageHeight = pageHeight;
Scale = 1d;
this.DxfSource = dxfSource ?? throw new ArgumentNullException(nameof(dxfSource));
this.PdfDestination = pdfDestination ?? throw new ArgumentNullException(nameof(pdfDestination));
}
public void BinaryOperatorTest()
{
var oneInch1 = PdfMeasurement.Inches(1.0);
var oneInch2 = PdfMeasurement.Mm(25.4);
Assert.Equal(2.0, (oneInch1 + oneInch2).RawValue);
Assert.Equal(50.8, (oneInch2 + oneInch1).RawValue);
}
private static string ConvertToString(DxfFile dxf, PdfMeasurement?pageWidth = null, PdfMeasurement?pageHeight = null, double scale = 1.0)
{
var options = new DxfToPdfConverterOptions(
pageWidth ?? PdfMeasurement.Inches(8.5),
pageHeight ?? PdfMeasurement.Inches(11.0),
scale);
return(ConvertToString(dxf, options));
}
public (double scaleA, double scaleB) GetUnitAdjustedScale(DrawingSettings drawingSettings)
{
var drawingUnits = drawingSettings.UnitFormat == UnitFormat.Architectural ? PdfMeasurementType.Inch : PdfMeasurementType.Mm;
var scaleAValue = DrawingSettings.TryParseUnits(ScaleA, out var parsedScaleA) ? parsedScaleA : 1.0;
var scaleBValue = DrawingSettings.TryParseUnits(ScaleB, out var parsedScaleB) ? parsedScaleB : 1.0;
var scaleAMeasurement = new PdfMeasurement(scaleAValue, drawingUnits);
return(scaleAMeasurement.ConvertTo(PdfMeasurementType.Point).RawValue, scaleBValue);
}
private static PdfText ConvertText(DxfText text, DxfLayer layer, Matrix4 affine, Matrix4 scale)
{
// TODO horizontal and vertical justification (manual calculation for PDF, measure text?)
// TODO Thickness, Rotation, TextStyleName, SecondAlignmentPoint
// TODO IsTextUpsideDown, IsTextBackwards
// TODO RelativeXScaleFactor
// TODO TextHeight unit? Same as other scale?
// TODO TextStyleName probably maps to something meaningfull (bold, italic, etc?)
PdfMeasurement fontSize = scale.Transform(new Vector(0, text.TextHeight, 0))
.ToPdfPoint(PdfMeasurementType.Point).Y;
PdfPoint location = affine.Transform(text.Location).ToPdfPoint(PdfMeasurementType.Point);
var pdfStreamState = new PdfStreamState(GetPdfColor(text, layer));
return(new PdfText(text.Value, Font, fontSize, location, pdfStreamState));
}
public ConverterPdfRect(PdfMeasurement left, PdfMeasurement right, PdfMeasurement bottom, PdfMeasurement top)
{
if (left.AsPoints() >= right.AsPoints())
{
throw new ArgumentOutOfRangeException(nameof(left), left, "left >= right");
}
if (bottom.AsPoints() >= top.AsPoints())
{
throw new ArgumentOutOfRangeException(nameof(bottom), bottom, "bottom >= top (PDF 'bottom' is zero)");
}
this.Left = left;
this.Right = right;
this.Bottom = bottom;
this.Top = top;
}
private static IEnumerable <IPdfPathItem> ConvertPoint(DxfModelPoint point, DxfLayer layer, Matrix4 affine, Matrix4 scale)
{
var p = affine.Transform(point.Location).ToPdfPoint(PdfMeasurementType.Point);
var thickness = scale.Transform(new Vector(point.Thickness, 0, 0)).ToPdfPoint(PdfMeasurementType.Point).X;
if (thickness.RawValue < 1)
{
thickness = PdfMeasurement.Points(1);
}
// TODO fill circle? For now fake it via stroke thickness.
var pdfStreamState = new PdfStreamState(
strokeColor: GetPdfColor(point, layer),
strokeWidth: thickness);
yield return(new PdfCircle(p, thickness / 2, pdfStreamState));
}
/// <summary>
/// Creates a PDF destination rectangle from the given DXF rectangle and keeps the aspect ratio.
/// Optionally, a <paramref name="margin"/> can be defined.
/// </summary>
/// <param name="srcRect">The DXF source rectangle.</param>
/// <param name="maxWidth">The maximum width of the PDF output including <paramref name="margin"/>.</param>
/// <param name="maxHeight">The maximum height of the PDF output including <paramref name="margin"/>.</param>
/// <param name="margin">[optional] The margin.</param>
/// <returns>The PDF destination rectangle.</returns>
public static ConverterPdfRect KeepAspectRatio(ConverterDxfRect srcRect, PdfMeasurement maxWidth,
PdfMeasurement maxHeight, PdfMeasurement margin = default(PdfMeasurement))
{
double maxWidthPts = maxWidth.AsPoints();
double maxHeightPts = maxHeight.AsPoints();
double marginPts = margin.AsPoints();
double scaleX = (maxWidthPts - 2 * marginPts) / srcRect.Width;
double scaleY = (maxHeightPts - 2 * marginPts) / srcRect.Height;
double scale = Math.Min(scaleX, scaleY);
PdfMeasurement left = margin;
PdfMeasurement right = PdfMeasurement.Points(marginPts + scale * srcRect.Width);
PdfMeasurement bottom = margin;
PdfMeasurement top = PdfMeasurement.Points(marginPts + scale * srcRect.Height);
return(new ConverterPdfRect(left, right, bottom, top));
}
public void VerifyFillTest()
{
var builder = new PdfPathBuilder()
{
new PdfLine(
new PdfPoint(PdfMeasurement.Points(0.0), PdfMeasurement.Points(0.0)),
new PdfPoint(PdfMeasurement.Points(1.0), PdfMeasurement.Points(1.0))),
new PdfLine(
new PdfPoint(PdfMeasurement.Points(2.0), PdfMeasurement.Points(2.0)),
new PdfPoint(PdfMeasurement.Points(3.0), PdfMeasurement.Points(3.0)),
state: new PdfStreamState(strokeWidth: PdfMeasurement.Points(1.1))),
new PdfLine(
new PdfPoint(PdfMeasurement.Points(4.0), PdfMeasurement.Points(4.0)),
new PdfPoint(PdfMeasurement.Points(5.0), PdfMeasurement.Points(5.0)),
state: new PdfStreamState(nonStrokeColor: new PdfColor(1.0, 0.0, 0.0))),
new PdfLine(
new PdfPoint(PdfMeasurement.Points(6.0), PdfMeasurement.Points(6.0)),
new PdfPoint(PdfMeasurement.Points(7.0), PdfMeasurement.Points(7.0)),
state: new PdfStreamState(nonStrokeColor: new PdfColor(0.0, 1.0, 0.0), strokeWidth: PdfMeasurement.Points(2.2)))
};
AssertPathBuilderContains(builder, @"
0 w
0 0 0 RG
0 0 0 rg
0.00 0.00 m
1.00 1.00 l
S
1.1 w
2.00 2.00 m
3.00 3.00 l
S
0 w
1 0 0 rg
4.00 4.00 m
5.00 5.00 l
S
2.2 w
0 1 0 rg
6.00 6.00 m
7.00 7.00 l
S
");
}
public void VerifyGraphicsStreamTest()
{
var page = new PdfPage(PdfMeasurement.Inches(8.5), PdfMeasurement.Inches(11.0));
var width = 100;
var height = 100;
var bpp = 3;
var imageBytes = new byte[width * height * bpp]; // 0 is fine for this
var imageObject = new PdfImageObject(width, height, PdfColorSpace.DeviceRGB, 8, imageBytes, new ASCIIHexEncoder());
var xScale = 400;
var yScale = 400;
var xOffset = 100;
var yOffset = 100;
var transform = PdfMatrix.ScaleThenTranslate(xScale, yScale, xOffset, yOffset);
var imageItem = new PdfImageItem(imageObject, transform);
page.Items.Add(imageItem);
// placement of image
var expectedStream = @"
q
400.00 0.00 0.00 400.00 100.00 100.00 cm
/Im5 Do
Q
";
AssertPageContains(page, expectedStream);
// raw image data
var expectedImageData = @"
<</Type /XObject
/Subtype /Image
/Width 100
/Height 100
/ColorSpace /DeviceRGB
/BitsPerComponent 8
/Length 60939
/Filter [/ASCIIHexDecode]>>
stream
";
AssertPageContains(page, expectedImageData);
}
public void VerifyStreamFilterTest()
{
var page = new PdfPage(PdfMeasurement.Inches(8.5), PdfMeasurement.Inches(11.0), new ASCIIHexEncoder());
var text = new PdfText("foo", new PdfFontType1(PdfFontType1Type.Helvetica), PdfMeasurement.Points(12.0), new PdfPoint(PdfMeasurement.Inches(1.0), PdfMeasurement.Inches(1.0)));
page.Items.Add(text);
var expected = @"
<</Length 185
/Filter [/ASCIIHexDecode]
>>
stream
3020770D0A30203020302052470D0A30203020302072670D0A42540D0A202020202F46312031322E30302054660D0A2020202037322E30302037322E30302054
640D0A202020205B28666F6F295D20544A0D0A45540D0A530D0A>
endstream
endobj
";
AssertPageContains(page, expected);
}
public void AspectRatioIsKept(int maxWidth, int maxHeight)
{
ConverterDxfRect src = new ConverterDxfRect(0, 5, 0, 5);
PdfMeasurement pdfMaxWidth = PdfMeasurement.Points(maxWidth);
PdfMeasurement pdfMaxHeight = PdfMeasurement.Points(maxHeight);
ConverterPdfRect sut = ConverterPdfRect.KeepAspectRatio(src, pdfMaxWidth, pdfMaxHeight);
Assert.True(sut.Width.AsPoints() <= maxWidth);
Assert.True(sut.Height.AsPoints() <= maxHeight);
Assert.Equal(src.Width, src.Height); // otherwise test below is wrong
if (maxWidth > maxHeight)
{
Assert.Equal(pdfMaxHeight, sut.Height);
}
else
{
Assert.Equal(pdfMaxWidth, sut.Width);
}
}
public void VerifyFontsAreReusedTest()
{
var file = new PdfFile();
var page = PdfPage.NewLetter();
var font = new PdfFontType1(PdfFontType1Type.Helvetica);
// font used twice on one page
page.Items.Add(new PdfText("foo", font, PdfMeasurement.Points(12.0), new PdfPoint()));
page.Items.Add(new PdfText("foo", font, PdfMeasurement.Points(12.0), new PdfPoint()));
file.Pages.Add(page);
// font used a third time on another page
page = PdfPage.NewLetter();
page.Items.Add(new PdfText("foo", font, PdfMeasurement.Points(12.0), new PdfPoint()));
file.Pages.Add(page);
// font objects should only be listed once
AssertFileContains(file, "/Resources <</Font <</F1 5 0 R>>>>");
AssertFileDoesNotContain(file, "/Resources <</Font <</F1 5 0 R>> /Font <</F1 5 0 R>>"); // duplicate font resource object
AssertFileDoesNotContain(file, "/Resources <</Font <</F1 5 0 R>> /Font <</F2 6 0 R>>"); // duplicate font resource
AssertFileContainsCount(file, "<</Type /Font /Subtype /Type1 /BaseFont /Helvetica>>", 1);
}
public override async Task Plot(Drawing drawing, ViewPort viewPort, Stream outputStream, Func <string, Task <byte[]> > contentResolver)
{
var converter = new DxfToPdfConverter();
var fileSettings = new DxfFileSettings()
{
FileVersion = DxfFileVersion.R2004,
};
var dxfFile = DxfFileHandler.ToDxfFile(drawing, viewPort, fileSettings);
var pageWidth = new PdfMeasurement(ViewModel.DisplayWidth, ViewModel.DisplayUnit);
var pageHeight = new PdfMeasurement(ViewModel.DisplayHeight, ViewModel.DisplayUnit);
var plotViewPort = ViewModel.ViewPort;
var viewPortWidth = ViewModel.DisplayWidth / ViewModel.DisplayHeight * plotViewPort.ViewHeight;
var dxfRect = new ConverterDxfRect(plotViewPort.BottomLeft.X, plotViewPort.BottomLeft.X + viewPortWidth, plotViewPort.BottomLeft.Y, plotViewPort.BottomLeft.Y + plotViewPort.ViewHeight);
var pdfRect = new ConverterPdfRect(
new PdfMeasurement(0.0, ViewModel.DisplayUnit),
new PdfMeasurement(ViewModel.DisplayWidth, ViewModel.DisplayUnit),
new PdfMeasurement(0.0, ViewModel.DisplayUnit),
new PdfMeasurement(ViewModel.DisplayHeight, ViewModel.DisplayUnit));
var options = new DxfToPdfConverterOptions(pageWidth, pageHeight, dxfRect, pdfRect, contentResolver: contentResolver);
var pdfFile = await converter.Convert(dxfFile, options);
pdfFile.Save(outputStream);
}
public void SourceDestinationTransformTest()
{
var dxf = new DxfFile();
// line from (2,2) to (3,3)
dxf.Entities.Add(new DxfLine(new DxfPoint(2, 2, 0), new DxfPoint(3, 3, 0)));
var options = new DxfToPdfConverterOptions(PdfMeasurement.Mm(210), PdfMeasurement.Mm(297),
new ConverterDxfRect(2, 3, 2, 3),
new ConverterPdfRect(PdfMeasurement.Points(100), PdfMeasurement.Points(200), PdfMeasurement.Points(300), PdfMeasurement.Points(400)));
var pdf = ConvertToString(dxf, options);
// expected line from (100,300)pt to (200,400)pt
var expected = NormalizeCrLf(@"
stream
0 w
0 0 0 RG
0 0 0 rg
100.00 300.00 m
200.00 400.00 l
S
endstream".Trim());
Assert.Contains(expected, pdf);
}
private static PdfMeasurement GetStrokeWidth(DxfEntity entity, DxfLayer layer)
{
// TODO many entities have a Thickness property (which is often zero).
DxfLineWeight lw = new DxfLineWeight {
Value = entity.LineweightEnumValue
};
DxfLineWeightType type = lw.LineWeightType;
if (type == DxfLineWeightType.ByLayer)
{
lw = layer.LineWeight;
}
if (lw.Value == 0)
{
return(default(PdfMeasurement));
}
if (lw.Value < 0)
{
return(PdfMeasurement.Points(1)); // smallest valid stroke width
}
// TODO What is the meaning of this short? Some default app-dependent table? DXF spec doesn't tell.
// QCad 1mm => lw.Value==100
return(PdfMeasurement.Mm(lw.Value / 100.0));
}
public PdfArc(PdfPoint center, PdfMeasurement radius, double startAngle, double endAngle, PdfStreamState state = default(PdfStreamState))
: base(center, radius, radius, startAngle: startAngle, endAngle: endAngle, state: state)
{
}
public void RawPointsNoopTest()
{
var m = PdfMeasurement.Points(42.0);
Assert.Equal(42.0, m.AsPoints());
}
public void StringEscapeSequencesTest()
{
var page = PdfPage.NewLetter();
var text = new PdfText(@"outer (inner \backslash) after", new PdfFontType1(PdfFontType1Type.Helvetica), PdfMeasurement.Points(12.0), new PdfPoint());
page.Items.Add(text);
AssertPageContains(page, @"[(outer \(inner \\backslash\) after)] TJ");
}
public void VerifyFontsAreAddedOnSaveTest()
{
var file = new PdfFile();
var page = PdfPage.NewLetter();
var text = new PdfText("foo", new PdfFontType1(PdfFontType1Type.Helvetica), PdfMeasurement.Points(12.0), new PdfPoint());
page.Items.Add(text);
file.Pages.Add(page);
Assert.Equal(0, file.Fonts.Count);
using (var ms = new MemoryStream())
{
file.Save(ms);
}
Assert.True(ReferenceEquals(text.Font, file.Fonts.Single()));
}
public PdfStreamState(PdfColor?nonStrokeColor = null, PdfColor?strokeColor = null, PdfMeasurement?strokeWidth = null)
{
NonStrokeColor = nonStrokeColor ?? default(PdfColor);
StrokeColor = strokeColor ?? default(PdfColor);
StrokeWidth = strokeWidth ?? default(PdfMeasurement);
}