Technisch artikel

PDFlibPas EMF-import: PolyDraw-, Polyline- en Bezier-regels

Teken een V van drie punten met Canvas.Polyline terwijl een gele brush is geselecteerd, converteer de metafile naar PDF, en een naïeve converter geeft een effen gele driehoek terug. Dezelfde converter kan een Bezier naar het verkeerde control point buigen en een PolyDraw-rechthoek met drie zijden achterlaten. Elk geval spoor terug op één regel uit [MS-EMF]: EMR_POLYBEZIER begint bij punt 0, polylines zijn open en krijgen uitsluitend stroke, PT_CLOSEFIGURE is een vlagbit, en puntaantallen moeten binnen de recordgrootte passen

Een device context heeft status die een PDF-path niet heeft

Een enhanced metafile is een opname van GDI-aanroepen tegen een device context, en de helft van wat een Poly*-record betekent, ligt buiten zijn punten: of de figuur open is, of hij bij de huidige positie begint, welke pen en brush zijn geselecteerd, en op welke byte-offset de punten beginnen. PDF heeft daar geen van allen. Het heeft een path, een current point daarin, en een tekenoperator die kiest tussen stroke (S), fill (f) en beide (B). De vector-EMF-importeur in PDFlibPas, de losLab PDF-library voor Delphi, speelt die device-context-status mee met de coördinaten, en de regels hieronder beschrijven hoe hij elk record afbeeldt

De Poly*-familie bestaat bovendien in twee breedtes. Elk 32-bit record zoals EMR_POLYLINE heeft een 16-bit tweeling zoals EMR_POLYLINE16 die punten opslaat als SmallInt-paren, en GDI legt de compacte vorm vast zodra elke coördinaat past. Alledaagse tekeningen bereiken de 32-bit handlers van een converter daarom zelden. Haal dezelfde punten door beide breedtes en vergelijk de paden; dat is de goedkoopste audit die er is. Alle hier behandelde records behoren tot de groep tekenrecords in [MS-EMF] 2.3.5

RecordBegint bijGesloten?Huidige positie
EMR_POLYBEZIERPunt 0NeeNiet gebruikt, niet bijgewerkt
EMR_POLYLINEPunt 0Nee (alleen pen)Niet gebruikt, niet bijgewerkt
EMR_POLYLINETOHuidige positieNee (alleen pen)Gebruikt en bijgewerkt
EMR_POLYPOLYLINEEerste punt van elke polylineNee (alleen pen)Niet gebruikt, niet bijgewerkt
EMR_POLYDRAWEerste PT_MOVETO, of huidige positieAlleen waar PT_CLOSEFIGURE is gezetGebruikt en bijgewerkt

Waar begint een EMR_POLYBEZIER-curve eigenlijk?

Een EMR_POLYBEZIER-curve begint bij punt 0, en alleen de punten vanaf index 1 worden in drietallen gegroepeerd als control point, control point, eindpunt. Een record met 7 punten tekent dus twee cubic segmenten: punt 0 is de start, punten 1 tot 3 vormen het eerste segment, en 4 tot 6 het tweede. Beginnen met groeperen bij punt 0 en het startpunt wordt als eerste control point opgebruikt. Elk later segment schuift één positie op. De uitvoer is nog steeds een vloeiende curve, alleen de verkeerde. PDFlibPas opent het path met m op punt 0, in beide recordbreedtes, en geeft daarna één c per volledig drietal uit

PDFlibPas-diagram van een EMR_POLYBEZIER-record met zeven punten waarin punt nul het path opent met m en de punten één tot drie en vier tot zes elk één cubic c-segment vormen, met de correcte groepering naast de groepering die het startpunt als control point opgebruikt
Punt 0 is het startpunt en alleen volledige drietallen erna worden cubic segmenten, dus een PolyBezier met zeven punten rendert als m plus twee c-operators

En een aantal dat niet 1 plus een veelvoud van 3 is? Het record is misvormd. Ons standpunt is dat de achterblijvende een of twee punten moeten worden weggegooid. Ze in een curve stikken door een ontbrekend control point te verzinnen, levert een vorm op die geen enkel GDI-apparaat ooit tekende, en een reader die de PDF naast het origineel legt, kan op geen enkele manier zien welk helft van de curve is verzonnen

PolyDraw-typebytes 3 en 5

In EMR_POLYDRAW is PT_CLOSEFIGURE (waarde 1) een bit dat met OR in PT_LINETO (2) of PT_BEZIERTO (4) terechtkomt, dus een perfect geldig typebyte kan 3 of 5 zijn. Het punttype is de byte met dat bit uitgemaskeerd; de vlag zelf betekent "sluit de figuur af na het segment dat op dit punt eindigt". Een handler die de byte in een Pascal-case-statement tegen losse waarden matcht, ziet 3 of 5 nooit ergens passen. Die punten worden overgeslagen. Een met PolyDraw getekende rechthoek verliest zijn sluitzijde, en een Bezier-drietal waarvan het laatste punt de vlag draagt verliest dat punt, wat elk later drietal één positie uit de pas laat lopen

PDFlibPas dispatcht op Types[i] and not PT_CLOSEFIGURE en sluit de figuur pas als een segment compleet is: direct na de lijn bij een gesloten PT_LINETO, en na het derde punt van een Bezier-groep. Een misvormd bestand dat de vlag op het eerste of tweede punt van een drietal zet, sluit de figuur daardoor niet halverwege een curve. Twee regels meer horen in dezelfde handler:

  • Alleen de eerste PT_MOVETO in een record start het path; latere moves openen nieuwe subpaths. Een 16-bit EMR_POLYDRAW16 met drie figuren moet dus drie subpaths opleveren, en een handler die het path bij elke move herstart, houdt alleen de laatste over
  • Een PolyDraw-record dat niet met PT_MOVETO begint, start op de huidige positie, zoals de recorddefinitie zegt. Een operator l of c schrijven zonder voorafgaande m is een content-stream-fout die elke PDF-viewer op zijn eigen manier oplost
PDFlibPas-anatomie van een EMR_POLYDRAW-typebyte waarin PT_CLOSEFIGURE vlagbit nul is dat via OR in PT_LINETO of PT_BEZIERTO terechtkomt, dus geldige typebytes 3 en 5 moeten met and not PT_CLOSEFIGURE gemaskeerd worden vóór de dispatch; het oude case-statement sloeg beide bytes over en gesloten figuren verloren hun laatste zijde
Maskeer de close-vlag af vóór de dispatch en geef de sluiting pas na een voltooide lijn of Bezier-drietal, anders laat PolyDraw stilletjes punten vallen

De gele driehoek: waarom een polyline nooit wordt gevuld

EMR_POLYLINE en EMR_POLYPOLYLINE zijn open figuren die alleen met de pen worden getekend, en in PDF sluit een fill-operator elke open subpath voordat hij haar tekent (ISO 32000-1 §8.5.3). Geeft u B of f voor een polyline van drie punten, dan tekent de viewer een gevulde driehoek in welke brushkleur dan ook die toevallig geldt. Dat is de gele V uit de openingsalinea, of de wig onder een trendlijn in een grafiek. PDFlibPas eindigt beide polyline-breedtes op S en raakt de brush nooit aan, wat de GDI-semantiek intact houdt: Polygon sluit en vult, Polyline doet geen van beide

PDFlibPas-vergelijking van een open V-polyline geëxporteerd uit EMR_POLYLINE: een correcte converter eindigt het path met de stroke-operator S en negeert de geselecteerde brush, terwijl f of B geven de open subpath impliciet sluit onder ISO 32000-1 8.5.3 en de gevulde wig onder een grafieklijn tekent
Een fill-operator sluit elke open subpath vóór het tekenen, dus polylines moeten eindigen in S zonder h, f of B op de subpath

PolylineTo en de pen die hij met rust moet laten

EMR_POLYLINETO tekent vanaf de huidige positie langs elk punt in het record, blijft open, en laat de huidige positie op het laatste punt achter. Penstatus is bezit van EMR_SELECTOBJECT en EMR_CREATEPEN, nooit van een tekenrecord-handler. Een special case die de pen binnen één record uitzet, heeft niets dat hem weer aanzet, dus elk later record verliest zijn omtrek. Voor de vorm met één punt: lees exact de punten die het record bevat en stop

PolyPolyline-punten staan na de counts-array

Het 32-bit EMR_POLYPOLYLINE slaat nPolys aantallen op en daarna cptl punten, dus de punten beginnen op byte-offset 32 + nPolys * 4. De valkuil zit in de Delphi-RTL. De unit Windows declareert TEMRPolyPolyline met aPolyCounts en aptl als arrays met één element, wat betekent dat aptl[0] alleen het eerste punt is wanneer nPolys 1 is. Indexeer aptl direct en elk multi-line record leest aantalwaarden als coördinaten. Erger nog: een sizecheck gebouwd op die layout wijst geldige multi-line records ronduit af. PDFlibPas berekent de offset zoals zijn PolyPolygon-handler dat altijd deed en tekent elke polyline als eigen open subpath, met één stroke op het eind. De 16-bit tweeling volgt hetzelfde patroon; haar segment voor segment tekenen zou line joins breken en een geselecteerde NULL_PEN negeren

Defaultobjecten en path-brackets

  • Een verse GDI device context heeft al BLACK_PEN en WHITE_BRUSH geselecteerd. Een metafile die zonder enige EMR_SELECTOBJECT tekent, is legaal en krijgt toch zwarte omtrekken; een converter die zonder pen begint, schrijft n (end path, niets tekenen) voor die records
  • Binnen een BeginPath / EndPath-bracket gebruikt een Polyline de huidige positie niet en werkt ze niet bij, dus ze moet op haar eerste punt een nieuwe subpath openen in plaats van door te lopen naar de vorige figuur, en er mag niets worden getekend totdat de bracket is gestroked of gevuld

Een testmetafile opnemen met TMetafileCanvas

De snelste manier om een converter aan deze regels te toetsen, is de drie risicovolle aanroepen in één enhanced metafile op te nemen met TMetafileCanvas. De procedure hieronder tekent de curves met een holle brush en selecteert daarna opzettelijk een effen gele brush vóór de polyline. Een correcte converter negeert die brush. Elke gele kleur in de output-PDF betekent dat de polyline is gevuld. PolyDraw heeft geen TCanvas-wrapper, dus hij gaat via de Windows API op de canvas-handle, met typebytes 3 en 5 die de close-vlag belasten

uses
  Winapi.Windows, System.Types, Vcl.Graphics;

procedure BuildPolyTestEmf(const FileName: string);
const
  // Een gesloten vierkant (3 = LINETO + CLOSEFIGURE), daarna een gesloten
  // Bezier-figuur waarvan het laatste control-drietal eindigt op 5 = BEZIERTO + CLOSEFIGURE
  DrawPts: array[0..7] of TPoint = (
    (X: 300; Y: 40), (X: 380; Y: 40), (X: 380; Y: 120), (X: 300; Y: 120),
    (X: 420; Y: 120), (X: 440; Y: 40), (X: 520; Y: 40), (X: 540; Y: 120));
  DrawTypes: array[0..7] of Byte = (
    PT_MOVETO, PT_LINETO, PT_LINETO, PT_LINETO or PT_CLOSEFIGURE,
    PT_MOVETO, PT_BEZIERTO, PT_BEZIERTO, PT_BEZIERTO or PT_CLOSEFIGURE);
var
  Mf: TMetafile;
  Canvas: TMetafileCanvas;
begin
  Mf := TMetafile.Create;
  try
    Mf.Enhanced := True;
    Mf.Width := 600;
    Mf.Height := 260;
    Canvas := TMetafileCanvas.Create(Mf, 0);
    try
      Canvas.Pen.Color := clNavy;
      Canvas.Pen.Width := 2;
      Canvas.Brush.Style := bsClear;    // alleen omtrekken voor de curves
      // Punt 0 is de start; 1..3 en 4..6 zijn twee cubic segmenten
      Canvas.PolyBezier([Point(20, 120), Point(60, 20), Point(100, 220),
        Point(140, 120), Point(180, 20), Point(220, 220), Point(260, 120)]);
      PolyDraw(Canvas.Handle, DrawPts[0], DrawTypes[0], Length(DrawPts));
      // Open V-vorm met een effen brush geselecteerd: gestroked, nooit
      // gesloten tot een gele driehoek
      Canvas.Brush.Style := bsSolid;
      Canvas.Brush.Color := clYellow;
      Canvas.Polyline([Point(20, 240), Point(120, 160), Point(220, 240)]);
    finally
      Canvas.Free;   // beëindigt de opname
    end;
    Mf.SaveToFile(FileName);
  finally
    Mf.Free;
  end;
end;

Elke coördinaat hier past in een SmallInt, dus GDI slaat normaal de 16-bit varianten op. Bij de 32-bit handlers komen vereist een producent die ze schrijft, of met de hand in elkaar gezette records. Handgebouwde bestanden hebben hun eigen valkuil, die naar boven komt als een VCL-fout "Metafile is not valid": TMetafile.LoadFromStream behandelt de stream alleen als EMF wanneer de resterende lengte strikt groter is dan de 108 bytes van TEnhMetaHeader. Een korte header, of een lege EMF van precies 108 bytes, wordt voor een WMF aangezien en geweigerd. Schrijf de volledige header van 108 bytes, extensievelden inbegrepen, vóór het eerste testrecord

De metafile importeren met ImportEMFFromFile

PDFlibPas importeert een EMF via ImportEMFFromFile of ImportEMFFromStream. Beide geven bij succes een image ID ongelijk nul terug en bij falen 0. GeneralOptions = 0 houdt het vectorpad vast waar dit artikel over gaat, terwijl 1 de metafile naar een bitmap rasteriseert. FontOptions = 1 voegt de fonts toe die de metafile gebruikt en bedt ze als subsets in. De streamvariant spoelt eerst terug naar positie 0 vóór het laden, dus geef hem een stream die de metafile bevat en niets anders

uses
  System.SysUtils, PDFlibrary;

procedure EmfToPdf(const EmfFile, PdfFile: WideString);
var
  PDF: TPDFlib;
  ImageID: Integer;
  PageOps: AnsiString;
begin
  PDF := TPDFlib.Create;
  try
    PDF.SetOrigin(1);              // linkerbovenhoek als origine voor DrawImage
    PDF.SetMeasurementUnits(0);    // punten
    // FontOptions 1 = de metafile-fonts toevoegen als ingebedde subsets
    // GeneralOptions 0 = vectorimport, 1 = bitmap
    ImageID := PDF.ImportEMFFromFile(EmfFile, 1, 0);
    if ImageID = 0 then
      raise Exception.Create('The metafile could not be imported');
    PDF.SelectImage(ImageID);
    // Bij een EMF zijn ImageWidth / ImageHeight de framemaat in punten
    PDF.DrawImage(36, 36, PDF.ImageWidth, PDF.ImageHeight);

    // De pagina roept alleen de geïmporteerde form aan: q ... cm /Name Do Q
    // (een optionele sanity-check die u aan uw eigen code kunt toevoegen)
    PageOps := PDF.GetPageContentToString;
    if Pos(AnsiString(' Do'), PageOps) = 0 then
      raise Exception.Create('Expected a form XObject invocation');

    if PDF.SaveToFile(PdfFile) <> 1 then
      raise Exception.Create('The PDF could not be saved');
  finally
    PDF.Free;
  end;
end;

Een vector-EMF-import wordt een form XObject, dus GetPageContentToString geeft alleen de save-, transform-, Do- en restore-reeks terug. De operators m, l, c, h en S die uit de Poly*-records voortkomen, zitten in de gecomprimeerde form-XObject-stream. Open het opgeslagen bestand in een PDF object inspector, decomprimeer die stream, en controleer voor het testbestand hierboven drie dingen: de polyline eindigt in S zonder h ervoor, elke close-vlag in de PolyDraw-figuren leverde een h op, en er staat geen f of B op een van deze subpaths. DrawImage schaalt een geïmporteerde EMF uniform met het kleinste van Width en Height, dus de tekening houdt zijn beeldverhouding, ook wanneer het kader dat u doorgeeft daar niet aan voldoet

Free Pascal-gebruikers lezen in hoe de PDFlibPas EMF-vectorimporteur onder Free Pascal bouwt; de record-semantiek is overal gelijk waar de importeur compileert

Puntaantallen in een EMF-bestand zijn onvertrouwde invoer

Elk puntaantal in een metafile moet tegen de recordgrootte worden gecontroleerd voordat er ook maar één punt wordt gekopieerd. EnumEnhMetaFile garandeert alleen dat de nSize van elk record binnen het bestand blijft. Hij controleert nooit of cptl met nSize klopt. Een handler die cptl punten met Move kopieert, leest bij een vervalst of corrupt aantal vrolijk door in de volgende records, of voorbij het einde van de metafile. PDFlibPas vergelijkt vaste header plus aantal keer bytes per punt met nSize voor PolyDraw, PolyBezier, PolyBezierTo, Polyline, PolylineTo en Polygon in beide breedtes, met één extra byte per punt voor de PolyDraw-typearray. Voor de PolyPoly-records moeten de aantallen per figuur bovendien samen niet meer uitkomen dan het opgegeven totaal, en figuren met nul punten worden overgeslagen

We verkiezen een record dat deze test faalt over te slaan boven het aantal afkappen tot wat past. Een afgekapt record tekent alsnog, en een half getekende figuur in een rapport is lastiger te spotten dan een ontbrekende. De controle is kort genoeg om in uw eigen parser te droppen; deze versie valideert een 32-bit EMR_POLYPOLYLINE en geeft een pointer naar zijn echte puntarray terug:

uses
  Winapi.Windows;

// Een controle om aan uw eigen EMF-parser toe te voegen (geen library-routine).
// Geeft nil terug tenzij het record echt de punten bevat die het aangeeft.
// De punten beginnen na de counts-array: 32 + nPolys * 4 bytes naar binnen, niet op
// aptl[0], dat de RTL als array met één element declareert
function PolyPolylinePoints(Rec: PEnhMetaRecord): PPoint;
var
  P: PEMRPolyPolyline;
  Count: PDWORD;
  PointsOffset, Total: Int64;
  I: Cardinal;
begin
  Result := nil;
  if (Rec^.iType <> EMR_POLYPOLYLINE) or (Rec^.nSize < 32) then
    Exit;
  P := PEMRPolyPolyline(Rec);
  if P^.nPolys = 0 then
    Exit;
  PointsOffset := 32 + Int64(P^.nPolys) * SizeOf(DWORD);
  if PointsOffset + Int64(P^.cptl) * SizeOf(TPoint) > Rec^.nSize then
    Exit;                         // vervalst of afgekapt aantal
  Total := 0;
  Count := @P^.aPolyCounts[0];    // met de pointer lopen: [0..0] triggert range checks
  for I := 1 to P^.nPolys do
  begin
    Inc(Total, Count^);
    Inc(Count);
  end;
  if Total > P^.cptl then
    Exit;                         // figuren claimen meer punten dan er zijn
  Result := PPoint(NativeUInt(Rec) + NativeUInt(PointsOffset));
end;

De volgorde telt hier. De punten-passen-test draait eerst, wat bewijst dat de counts-array binnen het record ligt voordat de lus haar doorloopt. De rekenkunde gebruikt Int64, omdat nPolys * 4 en cptl * 8 in 32 bits berekend kunnen omslaan naar een klein getal en de vergelijking toch laten passeren

Dezelfde record-semantiek geldt welke component uw rapporten ook rendert. HotPDF EMF- en WMF-vectorimport beschrijft hoe die component gradient- en hatch-brushes omzet in PDF-patterns, en vectorkunst, shaders en gradients in PDFlibPas toont hoe u dezelfde vormen rechtstreeks met de library-API tekent, zonder metafile

Om uw eigen rapportmetafiles door deze importeur te halen, heeft de PDFlibPas Delphi PDF library-pagina productdetails en de proefdownload