Dibuje una V de tres puntos con Canvas.Polyline con una brocha amarilla seleccionada, convierta el metafile a PDF, y un conversor ingenuo devuelve un triángulo amarillo sólido. El mismo conversor puede curvar una Bezier hacia el punto de control equivocado y dejar un rectángulo de PolyDraw con tres lados. Cada caso se remonta a una regla de [MS-EMF]: EMR_POLYBEZIER arranca en el punto 0, las polilíneas son abiertas y solo trazadas, PT_CLOSEFIGURE es un bit de flag, y los conteos de puntos deben caber en el tamaño del registro
Un device context tiene estado que un path de PDF no tiene
Un enhanced metafile es una grabación de llamadas GDI hechas contra un device context, y la mitad de lo que significa un registro Poly* vive fuera de sus puntos: si la figura es abierta, si arranca en la posición actual, qué pluma y brocha están seleccionadas, y en qué offset de byte comienzan los puntos. PDF no tiene nada de eso. Tiene un path, un punto actual dentro de ese path, y un operador de pintado que elige trazo (S), relleno (f) o ambos (B). El importador EMF vectorial de PDFlibPas, la biblioteca PDF de losLab para Delphi, reproduce ese estado del device context junto a las coordenadas, y las reglas de abajo describen cómo mapea cada registro
La familia Poly* además viene en dos anchos. Cada registro de 32 bits como EMR_POLYLINE tiene un gemelo de 16 bits como EMR_POLYLINE16 que guarda los puntos como pares SmallInt, y GDI graba la forma compacta siempre que cada coordenada quepa. Los dibujos cotidianos rara vez llegan así a los manejadores de 32 bits de un conversor. Pase los mismos puntos por ambos anchos y compare los paths; esa es la auditoría más barata que hay. Todos los registros cubiertos aquí pertenecen al grupo de registros de dibujo de [MS-EMF] 2.3.5
| Registro | Arranca en | ¿Cerrado? | Posición actual |
|---|---|---|---|
EMR_POLYBEZIER | Punto 0 | No | No se usa, no se actualiza |
EMR_POLYLINE | Punto 0 | No (solo pluma) | No se usa, no se actualiza |
EMR_POLYLINETO | Posición actual | No (solo pluma) | Se usa y se actualiza |
EMR_POLYPOLYLINE | Primer punto de cada polilínea | No (solo pluma) | No se usa, no se actualiza |
EMR_POLYDRAW | Primer PT_MOVETO, o posición actual | Solo donde PT_CLOSEFIGURE está activo | Se usa y se actualiza |
¿Dónde arranca en realidad la curva de un EMR_POLYBEZIER?
Una curva EMR_POLYBEZIER arranca en el punto 0, y solo los puntos desde el índice 1 en adelante se agrupan de a tres como punto de control, punto de control, punto final. Un registro con 7 puntos dibuja dos segmentos cúbicos: el punto 0 es el arranque, los puntos 1 a 3 forman el primer segmento, y 4 a 6 el segundo. Empiece a agrupar en el punto 0 y el punto de arranque se consume como primer punto de control. Cada segmento posterior se desplaza uno. La salida sigue siendo una curva suave, solo que la equivocada. PDFlibPas abre el path con m en el punto 0, en ambos anchos de registro, y escribe una c por cada terna completa posterior
¿Y un conteo que no es 1 más un múltiplo de 3? El registro está malformado. Nuestra postura es que el punto o los dos puntos finales deben soltarse. Empalmarlos en una curva inventando el punto de control que falta produce una forma que ningún device GDI dibujó jamás, y quien compare el PDF con el original no tiene forma de saber qué mitad de la curva está inventada
Los bytes de tipo 3 y 5 de PolyDraw
En EMR_POLYDRAW, PT_CLOSEFIGURE (valor 1) es un bit que se ORa dentro de PT_LINETO (2) o PT_BEZIERTO (4), así que un byte de tipo perfectamente válido puede ser 3 o 5. El tipo de punto es el byte con ese bit enmascarado; el flag mismo significa "cierra la figura después del segmento que termina en este punto". Un manejador que empareja el byte contra valores simples en un case de Pascal nunca ve que 3 o 5 empaten con nada. Esos puntos se saltan. Un rectángulo dibujado con PolyDraw pierde su lado de cierre, y una terna Bezier cuyo último punto trae el flag pierde ese punto, lo que descoloca cada terna posterior en uno
PDFlibPas despacha sobre Types[i] and not PT_CLOSEFIGURE y cierra la figura solo cuando un segmento está completo: justo después de la línea para un PT_LINETO cerrado, y tras el tercer punto de un grupo Bezier. Un archivo malformado que fije el flag en el primer o segundo punto de una terna no cierra pues la figura a mitad de una curva. Dos reglas más viven en el mismo manejador:
- Solo el primer
PT_MOVETOde un registro arranca el path; los movimientos posteriores abren subpaths nuevos. UnEMR_POLYDRAW16de 16 bits que guarde tres figuras debe producir tres subpaths, y un manejador que reinicie el path en cada movimiento conserva solo el último - Un registro PolyDraw que no arranque con
PT_MOVETOarranca en la posición actual, como dice la definición del registro. Escribir un operadorlocsin unmprevio es un error de content stream que cada visor de PDF resuelve a su manera
El triángulo amarillo: por qué una polilínea jamás se rellena
EMR_POLYLINE y EMR_POLYPOLYLINE son figuras abiertas dibujadas con la pluma sola, y en PDF un operador de relleno cierra cualquier subpath abierto antes de pintarlo (ISO 32000-1 §8.5.3). Emita B o f para una polilínea de tres puntos y el visor pinta un triángulo relleno del color de brocha que esté activo. Esa es la V amarilla del párrafo inicial, o la cuña bajo la línea de tendencia de un gráfico. PDFlibPas termina ambos anchos de polilínea con S y jamás toca la brocha, lo que mantiene intacta la semántica GDI: Polygon cierra y rellena, Polyline no hace ninguna de las dos
PolylineTo y la pluma que debe dejar tranquila
EMR_POLYLINETO dibuja desde la posición actual por cada punto del registro, se queda abierta, y deja la posición actual en el último punto. El estado de la pluma es propiedad de EMR_SELECTOBJECT y EMR_CREATEPEN, jamás de un manejador de registro de dibujo. Un caso especial que apague la pluma dentro de un registro no tiene nada que la vuelva a encender, así que cada registro posterior pierde su contorno. Para la forma de un punto, lea exactamente los puntos que el registro trae y deténgase
Los puntos de PolyPolyline quedan después del arreglo de conteos
El EMR_POLYPOLYLINE de 32 bits guarda nPolys conteos y luego cptl puntos, así que los puntos comienzan en el offset de byte 32 + nPolys * 4. La trampa vive en la RTL de Delphi. La unidad Windows declara TEMRPolyPolyline con aPolyCounts y aptl como arreglos de un elemento, lo que significa que aptl[0] es el primer punto solo cuando nPolys es 1. Indexe aptl directo y cada registro multilínea lee valores de conteo como coordenadas. Peor: una comprobación de tamaño construida sobre ese diseño rechaza de plano registros multilínea válidos. PDFlibPas calcula el offset igual que para PolyPolygon y dibuja cada polilínea como su propio subpath abierto, con un único trazo al final. El gemelo de 16 bits sigue el mismo patrón; dibujarlo segmento por segmento rompería las uniones de línea e ignoraría un NULL_PEN seleccionado
Objetos por defecto y corchetes de path
- Un device context GDI recién creado ya trae
BLACK_PENyWHITE_BRUSHseleccionados. Un metafile que dibuja sin un soloEMR_SELECTOBJECTes legal y aun así recibe contornos negros; un conversor que arranque sin pluma escriben(fin de path, no pintar nada) para esos registros - Dentro de un corchete
BeginPath/EndPath, unaPolylineni usa ni actualiza la posición actual, así que abre un subpath nuevo en su primer punto en lugar de unirse a la figura anterior. Nada se pinta hasta que el corchete se trace o se rellene
Grabar un metafile de prueba con TMetafileCanvas
La forma más rápida de poner un conversor a prueba con estas reglas es grabar las tres llamadas riesgosas en un solo enhanced metafile con TMetafileCanvas. El procedure de abajo dibuja las curvas con brocha hueca, y luego selecciona deliberadamente una brocha amarilla sólida antes de la polilínea. Un conversor correcto ignora esa brocha. Cualquier amarillo en el PDF de salida significa que la polilínea se rellenó. PolyDraw no tiene envoltorio en TCanvas, así que va por la API de Windows sobre el handle del canvas, con bytes de tipo 3 y 5 ejercitando el flag de cierre
uses
Winapi.Windows, System.Types, Vcl.Graphics;
procedure BuildPolyTestEmf(const FileName: string);
const
// Un cuadrado cerrado (3 = LINETO + CLOSEFIGURE), luego una figura
// Bezier cuyo último terceto de control termina con 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; // solo contornos para las curvas
// El punto 0 es el arranque; 1..3 y 4..6 son dos segmentos cúbicos
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));
// V abierta con pincel sólido seleccionado: se traza, nunca se cierra
// en un triángulo amarillo
Canvas.Brush.Style := bsSolid;
Canvas.Brush.Color := clYellow;
Canvas.Polyline([Point(20, 240), Point(120, 160), Point(220, 240)]);
finally
Canvas.Free; // termina la grabación
end;
Mf.SaveToFile(FileName);
finally
Mf.Free;
end;
end;
Toda coordenada aquí cabe en un SmallInt, así que GDI normalmente guardará las variantes de 16 bits. Llegar a los manejadores de 32 bits exige un productor que los escriba, o registros armados a mano. Los archivos hechos a mano traen su propia trampa, y aparece como un error VCL "Metafile is not valid": TMetafile.LoadFromStream trata el stream como EMF solo cuando el largo restante es estrictamente mayor que el TEnhMetaHeader de 108 bytes. Un encabezado corto, o un EMF vacío de exactamente 108 bytes, se toma por un WMF y se rechaza. Escriba el encabezado completo de 108 bytes, campos de extensión incluidos, antes del primer registro de prueba
Importar el metafile con ImportEMFFromFile
PDFlibPas importa un EMF vía ImportEMFFromFile o ImportEMFFromStream. Ambas devuelven un ID de imagen distinto de cero en éxito y 0 en fallo. GeneralOptions = 0 conserva la ruta vectorial de la que trata este artículo, mientras que 1 rasteriza el metafile a un bitmap. FontOptions = 1 agrega las fuentes que usa el metafile y las incrusta como subconjuntos. La variante de stream rebobina a la posición 0 antes de cargar, así que entréguele un stream que contenga el metafile y nada más
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); // origen arriba a la izquierda para DrawImage
PDF.SetMeasurementUnits(0); // puntos
// FontOptions 1 = agrega las fuentes del metafile como subconjuntos incrustados
// GeneralOptions 0 = importación vectorial, 1 = bitmap
ImageID := PDF.ImportEMFFromFile(EmfFile, 1, 0);
if ImageID = 0 then
raise Exception.Create('The metafile could not be imported');
PDF.SelectImage(ImageID);
// Para un EMF, ImageWidth / ImageHeight son el tamaño del marco en puntos
PDF.DrawImage(36, 36, PDF.ImageWidth, PDF.ImageHeight);
// La página solo invoca el form importado: q ... cm /Name Do Q
// (una comprobación de cordura opcional que puede agregar a su propio código)
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;
Una importación EMF vectorial se vuelve un form XObject, así que GetPageContentToString devuelve solo la secuencia de save, transform, Do y restore. Los operadores m, l, c, h y S generados de los registros Poly* viven en el stream comprimido del form XObject. Abra el archivo guardado en un inspector de objetos PDF, descomprima ese stream, y revise tres cosas para el archivo de prueba de arriba: la polilínea termina en S sin ningún h antes, cada flag de cierre de las figuras PolyDraw produjo un h, y no aparece ningún f ni B en ninguno de esos subpaths. DrawImage escala un EMF importado uniformemente por el menor entre Width y Height, así que el dibujo conserva su relación de aspecto aun cuando la caja que usted pase no la respete
Quien use Free Pascal puede leer cómo el importador vectorial EMF de PDFlibPas se construye bajo Free Pascal; la semántica de los registros es idéntica donde sea que compile el importador
Los conteos de puntos de un archivo EMF son entrada no confiable
Cada conteo de puntos de un metafile debe comprobarse contra el tamaño del registro antes de copiar un solo punto. EnumEnhMetaFile garantiza únicamente que el nSize de cada registro se mantenga dentro del archivo. Jamás comprueba que cptl concuerde con nSize. Un manejador que copie cptl puntos con Move leerá felizmente dentro de los registros siguientes, o pasado el fin del metafile, en cuanto el conteo se falsifique o corrompa. PDFlibPas compara encabezado fijo más conteo por bytes por punto contra nSize para PolyDraw, PolyBezier, PolyBezierTo, Polyline, PolylineTo y Polygon en ambos anchos, sumando un byte por punto para el arreglo de tipos de PolyDraw. Para los registros PolyPoly los conteos por figura también deben sumar a lo sumo el total declarado, y las figuras con cero puntos se saltan
Preferimos saltar un registro que falle esta prueba antes que ajustar el conteo a lo que quepa. Un registro ajustado igual dibuja, y una figura parcialmente dibujada en un reporte es más difícil de ver que una faltante. La comprobación es lo bastante corta para soltarla en su propio parser; esta versión valida un EMR_POLYPOLYLINE de 32 bits y devuelve un puntero a su arreglo real de puntos:
uses
Winapi.Windows;
// Una comprobación para agregar a su propio parser EMF (no es una rutina de la biblioteca).
// Devuelve nil salvo que el registro realmente guarde los puntos que declara.
// Los puntos comienzan después del arreglo de conteos: 32 + nPolys * 4 bytes adentro,
// no en aptl[0], que la RTL declara como arreglo de un elemento
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; // conteo falsificado o truncado
Total := 0;
Count := @P^.aPolyCounts[0]; // recorrer por puntero: [0..0] dispara los range checks
for I := 1 to P^.nPolys do
begin
Inc(Total, Count^);
Inc(Count);
end;
if Total > P^.cptl then
Exit; // las figuras reclaman más puntos de los que existen
Result := PPoint(NativeUInt(Rec) + NativeUInt(PointsOffset));
end;
El orden importa aquí. La prueba de cabida de puntos corre primero, lo que prueba que el arreglo de conteos vive dentro del registro antes de que el bucle lo recorra. La aritmética usa Int64 porque nPolys * 4 y cptl * 8 calculados en 32 bits pueden dar la vuelta a un número pequeño y pasar la comparación
La misma semántica de registros aplica sea cual sea el componente que renderice sus reportes. Importación vectorial EMF y WMF de HotPDF cubre cómo ese componente convierte brochas de gradiente y hatch en patrones de PDF, y gráficos vectoriales, shaders y gradientes en PDFlibPas muestra cómo dibujar las mismas formas directo con la API de la biblioteca, saltándose el metafile por completo
Para pasar sus propios metafiles de reportes por este importador, la página de la biblioteca PDF PDFlibPas para Delphi tiene los detalles del producto y la descarga de prueba