PDF generated from postscript vs. Quartz 2D - objective-c

Question

I'm working on a program which outputs needlework patterns as PDF files using Quartz 2D and Objective C. I've used another program which was coded in Python that outputs postscript files, which are converted to PDF when I open them in Preview. Since the second app is open source, I've been able to check that the settings I use to layout my PDF are the same, specifically the size of the squares and gap sizes between them.
In the image below, the output of the other program is on the left, while mine is on the right and both are at actual size. The problem I'm having is that at actual size, the gap lines in my output are intermittent, while in the other, all the gaps can be seen. I'm wondering if anyone knows about a rendering difference with postscript files which allows for this. I can zoom in on my output and the gaps show up, but I don't understand why there would be this difference.
The squares are set to be 8 pixels wide and tall, with a 1 pixel gap between them in both applications with 2 pixel wide gaps every 10 squares and mine is set to not use antialiasing. With my output, I've tried drawing directly to a CGPDFContext and drawing to a CGLayerRef then drawing the layer to the PDF Context, but I get the same result. I'm using integer values for positioning the layout and I'm pretty sure I've avoided trying to place squares in fractions of pixel positions.
I have also tried drawing the output to a CGBitmapContext and then drawing the resulting bitmap to the PDF context, but zooming in on that gives terrible artifacts since it is then a raster being magnified.
A last difference I've noted is that the file size of the postscript generated PDF is much smaller than the one I make, and I'm thinking that might have to do with the paths I draw since it says drawing to a PDF context records the drawing as a series of PDF drawing commands written to a file, which I would imagine takes up quite a bit of space compared to just displaying an image.
I have included my code to generate my PDFs below incase it would be helpful, but I'm really just wondering about if there is a rendering difference between postscript and Quartz that could explain these differences and if there is a way to make my output match up.
(The uploader says I need at least 10 reputation to post images, but I have this link http://i.stack.imgur.com/nr588.jpg again, the postscript output is on the left, my Quartz output is on the right and in my output, the gridlines are intermittent)
-(void)makePDF:(NSImage*)image withPixelArray:(unsigned char *)rawData{
NSString *currentUserHomeDirectory = NSHomeDirectory();
currentUserHomeDirectory = [currentUserHomeDirectory stringByAppendingString:#"/Desktop/"];
currentUserHomeDirectory = [currentUserHomeDirectory stringByAppendingString:[image name]];
currentUserHomeDirectory = [currentUserHomeDirectory stringByAppendingPathExtension:#"pdf"];
CGContextRef pdfContext;
CFStringRef path;
CFURLRef url;
int width = 792;
int height = 612;
CFMutableDictionaryRef myDictionary = NULL;
CFMutableDictionaryRef pageDictionary = NULL;
const char *filename = [currentUserHomeDirectory UTF8String];
path = CFStringCreateWithCString (NULL, filename,
kCFStringEncodingUTF8);
url = CFURLCreateWithFileSystemPath (NULL, path,
kCFURLPOSIXPathStyle, 0);
CFRelease (path);
myDictionary = CFDictionaryCreateMutable(NULL, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CGRect pageRect = CGRectMake(0, 0, width, height);
pdfContext = CGPDFContextCreateWithURL (url, &pageRect, myDictionary);
const CGFloat whitePoint[3]= {0.95047, 1.0, 1.08883};
const CGFloat blackPoint[3]={0,0,0};
const CGFloat gammavalues[3] = {2.2,2.2,2.2};
const CGFloat matrix[9] = {0.4124564, 0.3575761, 0.1804375, 0.2126729, 0.7151522, 0.072175, 0.0193339, 0.119192, 0.9503041};
CGColorSpaceRef myColorSpace = CGColorSpaceCreateCalibratedRGB(&whitePoint[3], &blackPoint[3], &gammavalues[3], &matrix[9]);
CGContextSetFillColorSpace (
pdfContext,
myColorSpace
);
int annotationNumber =0;
int match=0;
CFRelease(myDictionary);
CFRelease(url);
pageDictionary = CFDictionaryCreateMutable(NULL, 0,
&kCFTypeDictionaryKeyCallBacks,
&kCFTypeDictionaryValueCallBacks);
CFDataRef boxData = CFDataCreate(NULL,(const UInt8 *)&pageRect, sizeof (CGRect));
CFDictionarySetValue(pageDictionary, kCGPDFContextMediaBox, boxData);
int m = 0;
int sidestep = 0;
int downstep = 0;
int maxc = 0;
int maxr = 0;
int columnsPerPage = 70;
int rowsPerPage = 60;
int symbolSize = 8;
int gapSize=1;
CGContextSetShouldAntialias(pdfContext, NO);
int pages = ceil([image size].width/columnsPerPage) * ceil([image size].height/rowsPerPage);
for (int g=0; g<pages; g++) {
int offsetX = 32;
int offsetY = 32;
if (sidestep == ceil([image size].width/columnsPerPage)-1) {
maxc=[image size].width-sidestep*columnsPerPage;
}else {
maxc=columnsPerPage;
}
if (downstep == ceil([image size].height/rowsPerPage)-1) {
maxr=[image size].height-downstep*rowsPerPage;
}else {
maxr=rowsPerPage;
}
CGPDFContextBeginPage (pdfContext, pageDictionary);
CGContextTranslateCTM(pdfContext, 0.0, 612);
CGContextScaleCTM(pdfContext, 1.0, -1.0);
CGContextSetShouldAntialias(pdfContext, NO);
int r=0;
while (r<maxr){
int c=0;
while (c<maxc){
m = sidestep*columnsPerPage+c+downstep*[image size].width*rowsPerPage+r*[image size].width;
//Reset offsetX
if (c==0) {
offsetX=32;
}
//Increase offset for gridlines
if (c==0 && r%10==0&&r!=0) {
offsetY+=2;
}
if (c%10==0&&c!=0) {
offsetX+=2;
}
//DRAW SQUARES
CGContextSetRGBFillColor (pdfContext, (double)rawData[m*4]/255.,(double) rawData[m*4+1]/255., (double)rawData[m*4+2]/255., 1);
CGContextFillRect (pdfContext, CGRectMake (c*(symbolSize+gapSize)+offsetX, r*(symbolSize+gapSize)+offsetY, symbolSize, symbolSize ));
if ([usedColorsPaths count]!=0) {
for (int z=0; z<[usedColorsPaths count]; z++) {
if ([[[usedColorsPaths allKeys] objectAtIndex:z] isEqualToString:[NSString stringWithFormat:#"%i,%i,%i",rawData[m*4], rawData[m*4+1], rawData[m*4+2]]]) {
match=1;
if (rawData[m*4+3] == 0) {
CGContextDrawLayerAtPoint (pdfContext, CGPointMake(c*(symbolSize+1)+offsetX-2, r*(symbolSize+1)+offsetY-2), [Anotations colorAnnotations:pdfContext :[[usedColorsPaths objectForKey:[NSString stringWithFormat:#"%i,%i,%i",rawData[m*4],rawData[m*4+1],rawData[m*4+2]]]intValue] :symbolSize+4 :0]);
}
else{
CGContextDrawLayerAtPoint (pdfContext, CGPointMake(c*(symbolSize+1)+offsetX, r*(symbolSize+1)+offsetY),[Anotations colorAnnotations:pdfContext :[[usedColorsPaths objectForKey:[NSString stringWithFormat:#"%i,%i,%i",rawData[m*4], rawData[m*4+1], rawData[m*4+2]]] intValue] :symbolSize :0]);
}
break;
}
}
if (match==0) {
if (rawData[m*4+3] == 0) {
[usedColorsPaths setObject:[NSNumber numberWithInt:455] forKey:[NSString stringWithFormat:#"%i,%i,%i",rawData[m*4], rawData[m*4+1], rawData[m*4+2]]];
CGContextDrawLayerAtPoint (pdfContext, CGPointMake(c*(symbolSize+1)+offsetX-2, r*(symbolSize+1)+offsetY-2), [Anotations colorAnnotations:pdfContext :[[usedColorsPaths objectForKey:[NSString stringWithFormat:#"%i,%i,%i",rawData[m*4],rawData[m*4+1],rawData[m*4+2]]]intValue] :symbolSize+4 :0]);
}
else{
[usedColorsPaths setObject:[NSNumber numberWithInt:annotationNumber] forKey:[NSString stringWithFormat:#"%i,%i,%i",rawData[m*4], rawData[m*4+1], rawData[m*4+2]]];
CGContextDrawLayerAtPoint (pdfContext, CGPointMake(c*(symbolSize+1)+offsetX, r*(symbolSize+1)+offsetY), [Anotations colorAnnotations:pdfContext :[[usedColorsPaths objectForKey:[NSString stringWithFormat:#"%i,%i,%i",rawData[m*4],rawData[m*4+1],rawData[m*4+2]]]intValue] :symbolSize :0]);
}
annotationNumber++;
if (annotationNumber==9) {
annotationNumber=0;
}
}
match=0;
}
if ([usedColorsPaths count]==0) {
if (rawData[m*4+3] == 0) {
[usedColorsPaths setObject:[NSNumber numberWithInt:455] forKey:[NSString stringWithFormat:#"%i,%i,%i",rawData[m*4], rawData[m*4+1], rawData[m*4+2]]];
CGContextDrawLayerAtPoint (pdfContext, CGPointMake(c*(symbolSize+1)+offsetX-2, r*(symbolSize+1)+offsetY-2), [Anotations colorAnnotations:pdfContext :[[usedColorsPaths objectForKey:[NSString stringWithFormat:#"%i,%i,%i",rawData[m*4],rawData[m*4+1],rawData[m*4+2]]]intValue] :symbolSize+4 :0]);
}
else{
[usedColorsPaths setObject:[NSNumber numberWithInt:annotationNumber] forKey:[NSString stringWithFormat:#"%i,%i,%i",rawData[m*4], rawData[m*4+1], rawData[m*4+2]]];
CGContextDrawLayerAtPoint (pdfContext, CGPointMake(c*(symbolSize+1)+offsetX, r*(symbolSize+1)+offsetY), [Anotations colorAnnotations:pdfContext :[[usedColorsPaths objectForKey:[NSString stringWithFormat:#"%i,%i,%i",rawData[m*4],rawData[m*4+1],rawData[m*4+2]]]intValue] :symbolSize :0]);
}
annotationNumber++;
}
c++;
}
r++;
}
sidestep++;
if (sidestep == ceil([image size].width/columnsPerPage)) {
sidestep=0;
downstep+=1;
}
CGContextSaveGState(pdfContext);
CGPDFContextEndPage (pdfContext);
}
CGContextRelease(pdfContext);
CFRelease(pageDictionary);
CFRelease(boxData);}

Answer 1

I would need to see both PDF files to be able to make any judgement about why the sizes are different, or why the line spacing is intermittent, but here's a few points:
The most likely reason why the files are different sizes is that one PDF file has the content stream (the drawing operations you refer to) compressed, while the other does not.
In general emitting a sequence of drawing operations is more compact than including a bitmap image, unless the image resolution is very low. An RGB image takes 3 bytes for every image sample. If you think about a 1 inch square image at 300 dpi that's 300x300x3 bytes, or 270,000 bytes. If the image was all one colour (see example below) I could describe it in PDF drawing operations in 22 bytes.
You can't specify the size of the squares, or any of the other graphic features, in pixels. PDF is a vector based scalable format, not a bitmap format. I don't work on a Mac so I can't comment on your sample code but I suspect you are confusing the media width and height (specified in points) with pixels, these are not the same. The width and height describe a media size, there are no pixels involved until the PDF file is rendered to a bitmap, at that time the resolution of the device determines how many pixels are in each point.
Lets consider a PDF one inch square; that would have a width of 72 and a height of 72. I'll fill that rectangle with pure red, the PDF operations for that would be:
1 0 0 rg
0 0 72 72 re
So that's set the non-stroking colour to RGB (1, 0, 0), then starting at 0, 0 (bottom left) and extending for 72 points wide and 72 points high (one inch in each direction) fill a rectangle with that colour.
I view that on screen here on my PC that one inch square is rendered as 96 pixels by 96 pixels. Now I view it on an iPad with a retina display, the square is rendered 264 pixels by 264. Finally I print it to my laser printer, now the square is rendered 600 pixels by 600. The PDF content hasn't changed, but the number of pixels certainly has. A square is too simple of course, I could have used a circle instead, and obviously the high resolution display would have smoother curves. Of course, if I did use an image, the smoothness of the curve is 'baked in', the device rendering the PDF can't alter it if the resolution changes, all it can do is discard image samples to render down, or interpolate new ones to render up. That looks jagged when you scale down, and fuzzy when you scale up. The vector representation remains smooth, limited only by the current resolution.
The point of PDF is that the PDF isn't limited to one resolution, it can print to all of them and the output should be the same (as far as possible) on each device.
Now I suspect the problem is that you are "using integer values for positioning the layout", you can't do that and get correct (ie expected) results. You should be using real numbers for the layout which will allow you finer control over the position. Remember you are not addressing individual pixels, you are positioning graphics in a co-ordinate system, the resolution only comes into play when rendering (ie viewing or printing) the PDF file. You need to put aside concerns over pixels and just focus on the positioning.

Answer 2

So, after messing with it for another day,I think I found out that my problem was turning off antialiasing. I thought I wanted sharper drawing, but since PDF contains vector graphics, the antialiasing is okay and zooming in on the graphics keeps them sharp.
The first thing I did was in Preview, I went to Preview>preferences>PDF and selected "Define 100% scale as: 1 point equals 1 screen pixel". Doing this with my antialisaing turned off resulted in my image being displayed as I wanted, but zooming in on it, it seems like Preview had difficulty deciding when to draw the 1 pixel gaps.
I then altered my code by deleting the calls to turn off antialiasing and my output renders perfectly, so having antialiasing fixed my problem. Pretty embarrassing that this took me three days to figure out, but I'm glad for this simple fix.