Ticket #11: pkpgcounter-mediawork.patch

bin/pkpgcounter

@@ -81 +81 @@
                         grayscale pages from coloured pages but don't care
                         about ink usage per se.
 
+  -m, --media
+                        Activate the media size, format and duplex detection /
+                        tracking code.
+
   -rRESOLUTION, --resolution=RESOLUTION
                         The resolution in DPI to use when checking ink usage.
                         Lower resolution is faster but less accurate. Default

pkpgpdls/analyzer.py

@@ -3 +3 @@
 # pkpgcounter : a generic Page Description Language parser
 #
 # (c) 2003-2009 Jerome Alet <alet@librelogiciel.com>
+# Portions (c) 2009 Trever L. Adams <trever.adams@gmail.com>
+#
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
@@ -71 +73 @@
             self.closeFile()
         return size
 
+    def getMediaFormat(self) :
+        """Returns the job's media/format."""
+        result = None
+        self.openFile()
+        try :
+            try :
+                pdlhandler = self.detectPDLHandler()
+                result = pdlhandler.getMediaFormat()
+            except pdlparser.PDLParserError, msg :
+                raise pdlparser.PDLParserError, "Unsupported file format for %s (%s)" % (self.filename, msg)
+        finally :
+            self.closeFile()
+        return result
+
     def getInkCoverage(self, colorspace=None, resolution=None) :
         """Extracts the percents of ink coverage from the input file."""
         result = None
@@ -211 +227 @@
                             action="store_true",
                             dest="debug",
                             help="Activate debug mode.")
+    parser.add_option("-m", "--media",
+                            action="store_true",
+                            dest="media",
+                            help="Activate the detection of various media/format options of the job.")
     parser.add_option("-c", "--colorspace",
                             dest="colorspace",
                             type="cichoice",
@@ -236 +256 @@
             for arg in arguments :
                 try :
                     parser = PDLAnalyzer(arg, options)
-                    if not options.colorspace :
+                    if not options.colorspace and not options.media :
                         totalsize += parser.getJobSize()
-                    else :
+                    if options.colorspace :
                         (cspace, pages) = parser.getInkCoverage()
+                        if cspace == "BW" :
+                            cspace = "K"
+                        elif cspace == "GC" :
+                            cspace = ["GS", "CR"]
                         for page in pages :
                             lineparts = []
                             for k in cspace : # NB : this way we preserve the order of the planes
                                 try :
-                                    lineparts.append("%s : %s%%" % (k, ("%f" % page[k]).rjust(10)))
+                                    lineparts.append("%s: %s%%" % (k, ("%f" % page[k]).rjust(10)))
+                                except KeyError :
+                                    pass
+                            lines.append("  ".join(lineparts))
+                    if options.media :
+                        (mspace, pages) = parser.getMediaFormat()
+                        if lines == [] :
+                            haveOutput = False
+                        else :
+                            haveOutput = True
+                        i = 0
+                        for page in pages :
+                            lineparts = []
+                            for k in mspace : # NB : this way we preserve the order of the media format string
+                                try :
+                                    lineparts.append("%s: %s" % (k, ("%s" % page[k]).ljust(10)))
                                 except KeyError :
                                     pass
-                            lines.append("      ".join(lineparts))
+                            if haveOutput is False :
+                                lines.append("  ".join(lineparts))
+                            else :
+                                lines[i] = lines[i] + '  ' + ''.join(lineparts)
+                            i = i + 1
                 except (IOError, pdlparser.PDLParserError), msg :
                     sys.stderr.write("ERROR: %s\n" % msg)
                     sys.stderr.flush()
         except KeyboardInterrupt :
             sys.stderr.write("WARN: Aborted at user's request.\n")
             sys.stderr.flush()
-        if not options.colorspace :
+        if not options.colorspace and not options.media :
             sys.stdout.write("%i\n" % totalsize)
         else :
             sys.stdout.write("%s\n" % ("\n".join(lines)))

pkpgpdls/inkcoverage.py

@@ -73 +73 @@
     for (r, g, b) in img.getdata() :
         if not (r == g == b) :
             # optimize : if a single pixel is not gray the whole page is colored.
-            return { "G" : 0.0, "C" : 100.0 }
-    return { "G" : 100.0, "C" : 0.0 }
+            return { "GS" : 0.0, "CR" : 100.0 }
+    return { "GS" : 100.0, "CR" : 0.0 }
 
 def getPercentBW(img, nbpix) :
     """Extracts the percents of Black from a picture, once converted to gray levels."""
     if img.mode != "L" :
         img = img.convert("L")
-    return { "B" : 100.0 - getPercent(img, nbpix)["L"] }
+    return { "K" : 100.0 - getPercent(img, nbpix)["L"] }
 
 def getPercentRGB(img, nbpix) :
     """Extracts the percents of Red, Green, Blue from a picture, once converted to RGB."""

pkpgpdls/postscript.py

@@ -3 +3 @@
 # pkpgcounter : a generic Page Description Language parser
 #
 # (c) 2003-2009 Jerome Alet <alet@librelogiciel.com>
+# (c) 2009 Trever L. Adams <trever.adams@gmail.com>
+#
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
@@ -23 +25 @@
 
 import sys
 import os
+import re
 
 import pdlparser
 import inkcoverage
 
+findmediatype = re.compile(".*/MediaType [(]?([^)]*).*")
+findmediasize = re.compile(".*/PageSize \[?([\d.]*) ([\d.]*)\]?.*")
+findduplexoff = re.compile(r".*/Duplex false.*")
+findduplexon = re.compile(r".*/Duplex true.*")
+
+# Any zeros below indicate that the exact postscript size is unknown
+# Below are some papers that have multiple names. Don't use the Alias(es).
+# Cannocal              Alias
+# Leder                 11x17
+# Statement             half letter
+PostScriptPaperSizes = \
+                ("A0", 2384, 3370), \
+                ("A1", 1684, 2384), \
+                ("A2", 1191, 1684), \
+                ("A3", 842, 1191), \
+                ("A4", 595, 842), \
+                ("A5", 420, 595), \
+                ("A6", 297, 420), \
+                ("A7", 210, 297), \
+                ("A8", 148, 210), \
+                ("A9", 105, 148), \
+                ("A10", 73, 105), \
+                ("ArchA", 648, 864), \
+                ("ArchB", 864, 1296), \
+                ("ArchC", 1296, 1728), \
+                ("ArchD", 1728, 2592), \
+                ("ArchE", 2592, 3456), \
+                ("B0", 2835, 4008), \
+                ("B1", 2004, 2835), \
+                ("B2", 1417, 2004), \
+                ("B3", 1001, 1417), \
+                ("B4", 709, 1001), \
+                ("B5", 499, 709), \
+                ("B6", 354, 499), \
+                ("C0", 2599, 3677), \
+                ("C1", 1837, 2599), \
+                ("C2", 1298, 1837), \
+                ("C3", 918, 1298), \
+                ("C4", 649, 918), \
+                ("C5", 459, 649), \
+                ("C6", 323, 459), \
+                ("COM10Envelope", 0, 0), \
+                ("DL Envelope", 312, 624), \
+                ("Envelope #9", 279, 639), \
+                ("Envelope #10", 297, 684), \
+                ("Envelope #11", 324, 747), \
+                ("Envelope #12", 288, 792), \
+                ("Envelope #14", 360, 828), \
+                ("Executive", 540, 720), \
+                ("Foolscap", 612, 936), \
+                ("JDoublePostcard", 0, 0), \
+                ("JIS16K", 0, 0), \
+                ("JIS8K", 0, 0), \
+                ("JISB0", 0, 0), \
+                ("JISB1", 0, 0), \
+                ("JISB2", 0, 0), \
+                ("JISB3", 0, 0), \
+                ("JISB4", 0, 0), \
+                ("JISB5", 0, 0), \
+                ("JISB6", 0, 0), \
+                ("JISExec", 0, 0), \
+                ("JPostcard", 0, 0), \
+                ("Ledger", 792, 1224), \
+                ("Legal", 612, 1008), \
+                ("Letter", 612, 792), \
+                ("MonarchEnvelope", 279, 540), \
+                ("Statement", 396, 612) 
+
 class Parser(pdlparser.PDLParser) :
     """A parser for PostScript documents."""
     totiffcommands = [ 'gs -sDEVICE=tiff24nc -dPARANOIDSAFER -dNOPAUSE -dBATCH -dQUIET -r"%(dpi)i" -sOutputFile="%(outfname)s" "%(infname)s"' ]
@@ -77 +148 @@
             if number > self.pages[pagenum]["copies"] :
                 self.pages[pagenum]["copies"] = number
 
+    def getpapersize(self, x, y) :
+        for tempsize in PostScriptPaperSizes :
+            if (float(x) == float(tempsize[1])) and (float(y) == float(tempsize[2])) :
+                return tempsize[0]
+
     def natively(self) :
         """Count pages in a DSC compliant PostScript document."""
         pagecount = 0
@@ -87 +163 @@
         prescribe = False # Kyocera's Prescribe commands
         acrobatmarker = False
         pagescomment = None
+        duplexmode= "N"
+        mediasizelabel = "Letter"
+        mediatypelabel = "Plain"
         for line in self.infile :
             line = line.strip()
             parts = line.split()
@@ -145 +224 @@
                 if proceed and not notinteger :
                     pagecount += 1
                     self.pages[pagecount] = { "copies" : self.pages[pagecount-1]["copies"] }
+                self.pages[pagecount]["duplex"] = duplexmode
+                self.pages[pagecount]["mediatype"] = mediatypelabel
+                self.pages[pagecount]["mediasize"] = mediasizelabel
+            elif findduplexon.search(line) :
+                self.pages[pagecount]["duplex"] = "Y"
+                duplexmode=self.pages[pagecount]["duplex"]
+            elif findduplexoff.search(line) :
+                self.pages[pagecount]["duplex"] = "N"
+                duplexmode=self.pages[pagecount]["duplex"]
+            elif findmediatype.search(line) :
+                mediatype = findmediatype.search(line)
+                self.pages[pagecount]["mediatype"] = mediatype.group(1)
+                mediatypelabel = self.pages[pagecount]["mediatype"]
+            elif findmediasize.search(line) :
+                mediasize = findmediasize.search(line)
+                try :
+                    self.pages[pagecount]["mediasize"] = self.getpapersize(min(mediasize.group(1), mediasize.group(2)), max(mediasize.group(1), mediasize.group(2)))
+                    mediasizelabel = self.pages[pagecount]["mediasize"]
+                except :
+                    pass
             elif (not prescribe) \
                and (parts[:3] == [r"%%BeginResource:", "procset", "pdf"]) \
                and not acrobatmarker :
@@ -169 +268 @@
             self.logdebug("%s * page #%s" % (copies, pnum))
 
         self.logdebug("Internal parser said : %s pages" % pagecount)
-        return (pagecount, notrust)
+        return (pagecount, notrust, self.pages)
 
     def getJobSize(self) :
         """Count pages in PostScript document."""
         self.copies = 1
-        (nbpages, notrust) = self.natively()
+        (nbpages, notrust, pages) = self.natively()
         newnbpages = nbpages
         if notrust or not nbpages :
             try :
@@ -182 +281 @@
             except pdlparser.PDLParserError, msg :
                 self.logdebug(msg)
         return max(nbpages, newnbpages)
+
+    def getMediaFormat(self) :
+        """Discover media fomats/sizes in PostScript document."""
+        result = []
+        self.copies = 1
+        (nbpages, notrust, pages) = self.natively()
+        for k in pages :
+            if k > 0 :
+                result.append({"MT" : pages[k]["mediatype"],
+                               "MS" : pages[k]["mediasize"],
+                               "DU" : pages[k]["duplex"],
+                              })
+        return ((["MT", "MS", "DU"]), result)