home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2186 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  7.1 KB  |  264 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import Image
  5. import ImageFile
  6. import os
  7. import string
  8. import struct
  9. import sys
  10.  
  11. def isInt(f):
  12.     
  13.     try:
  14.         i = int(f)
  15.         if f - i == 0:
  16.             return 1
  17.         return 0
  18.     except:
  19.         return 0
  20.  
  21.  
  22. iforms = [
  23.     1,
  24.     3,
  25.     -11,
  26.     -12,
  27.     -21,
  28.     -22]
  29.  
  30. def isSpiderHeader(t):
  31.     h = (99,) + t
  32.     for i in [
  33.         1,
  34.         2,
  35.         5,
  36.         12,
  37.         13,
  38.         22,
  39.         23]:
  40.         if not isInt(h[i]):
  41.             return 0
  42.     
  43.     iform = int(h[5])
  44.     if iform not in iforms:
  45.         return 0
  46.     labrec = int(h[13])
  47.     labbyt = int(h[22])
  48.     lenbyt = int(h[23])
  49.     if labbyt != labrec * lenbyt:
  50.         return 0
  51.     return labbyt
  52.  
  53.  
  54. def isSpiderImage(filename):
  55.     fp = open(filename, 'rb')
  56.     f = fp.read(92)
  57.     fp.close()
  58.     bigendian = 1
  59.     t = struct.unpack('>23f', f)
  60.     hdrlen = isSpiderHeader(t)
  61.     if hdrlen == 0:
  62.         bigendian = 0
  63.         t = struct.unpack('<23f', f)
  64.         hdrlen = isSpiderHeader(t)
  65.     
  66.     return hdrlen
  67.  
  68.  
  69. class SpiderImageFile(ImageFile.ImageFile):
  70.     format = 'SPIDER'
  71.     format_description = 'Spider 2D image'
  72.     
  73.     def _open(self):
  74.         n = 108
  75.         f = self.fp.read(n)
  76.         
  77.         try:
  78.             self.bigendian = 1
  79.             t = struct.unpack('>27f', f)
  80.             hdrlen = isSpiderHeader(t)
  81.             if hdrlen == 0:
  82.                 self.bigendian = 0
  83.                 t = struct.unpack('<27f', f)
  84.                 hdrlen = isSpiderHeader(t)
  85.             
  86.             if hdrlen == 0:
  87.                 raise SyntaxError, 'not a valid Spider file'
  88.             hdrlen == 0
  89.         except struct.error:
  90.             raise SyntaxError, 'not a valid Spider file'
  91.  
  92.         h = (99,) + t
  93.         iform = int(h[5])
  94.         if iform != 1:
  95.             raise SyntaxError, 'not a Spider 2D image'
  96.         iform != 1
  97.         self.size = (int(h[12]), int(h[2]))
  98.         self.istack = int(h[24])
  99.         self.imgnumber = int(h[27])
  100.         if self.istack == 0 and self.imgnumber == 0:
  101.             offset = hdrlen
  102.             self.nimages = 1
  103.         elif self.istack > 0 and self.imgnumber == 0:
  104.             self.imgbytes = int(h[12]) * int(h[2]) * 4
  105.             self.hdrlen = hdrlen
  106.             self.nimages = int(h[26])
  107.             offset = hdrlen * 2
  108.             self.imgnumber = 1
  109.         elif self.istack == 0 and self.imgnumber > 0:
  110.             offset = hdrlen + self.stkoffset
  111.             self.istack = 2
  112.         else:
  113.             raise SyntaxError, 'inconsistent stack header values'
  114.         if (self.imgnumber > 0).bigendian:
  115.             self.rawmode = 'F;32BF'
  116.         else:
  117.             self.rawmode = 'F;32F'
  118.         self.mode = 'F'
  119.         self.tile = [
  120.             ('raw', (0, 0) + self.size, offset, (self.rawmode, 0, 1))]
  121.         self._SpiderImageFile__fp = self.fp
  122.  
  123.     
  124.     def tell(self):
  125.         if self.imgnumber < 1:
  126.             return 0
  127.         return self.imgnumber - 1
  128.  
  129.     
  130.     def seek(self, frame):
  131.         if self.istack == 0:
  132.             return None
  133.         if frame >= self.nimages:
  134.             raise EOFError, 'attempt to seek past end of file'
  135.         frame >= self.nimages
  136.         self.stkoffset = self.hdrlen + frame * (self.hdrlen + self.imgbytes)
  137.         self.fp = self._SpiderImageFile__fp
  138.         self.fp.seek(self.stkoffset)
  139.         self._open()
  140.  
  141.     
  142.     def convert2byte(self, depth = 255):
  143.         (min, max) = self.getextrema()
  144.         m = 1
  145.         if max != min:
  146.             m = depth / (max - min)
  147.         
  148.         b = -m * min
  149.         return self.point((lambda i, m = m, b = b: i * m + b)).convert('L')
  150.  
  151.     
  152.     def tkPhotoImage(self):
  153.         import ImageTk
  154.         return ImageTk.PhotoImage(self.convert2byte(), palette = 256)
  155.  
  156.  
  157.  
  158. def loadImageSeries(filelist = None):
  159.     if filelist == None or len(filelist) < 1:
  160.         return None
  161.     imglist = []
  162.     for img in filelist:
  163.         
  164.         try:
  165.             im = Image.open(img).convert2byte()
  166.         except:
  167.             None if not os.path.exists(img) else len(filelist) < 1
  168.             if not isSpiderImage(img):
  169.                 print img + ' is not a Spider image file'
  170.                 continue
  171.             continue
  172.  
  173.         im.info['filename'] = img
  174.         imglist.append(im)
  175.     
  176.     return imglist
  177.  
  178.  
  179. def makeSpiderHeader(im):
  180.     (nsam, nrow) = im.size
  181.     lenbyt = nsam * 4
  182.     labrec = 1024 / lenbyt
  183.     if 1024 % lenbyt != 0:
  184.         labrec += 1
  185.     
  186.     labbyt = labrec * lenbyt
  187.     hdr = []
  188.     nvalues = labbyt / 4
  189.     for i in range(nvalues):
  190.         hdr.append(0)
  191.     
  192.     if len(hdr) < 23:
  193.         return []
  194.     hdr[1] = 1
  195.     hdr[2] = float(nrow)
  196.     hdr[5] = 1
  197.     hdr[12] = float(nsam)
  198.     hdr[13] = float(labrec)
  199.     hdr[22] = float(labbyt)
  200.     hdr[23] = float(lenbyt)
  201.     hdr = hdr[1:]
  202.     hdr.append(0)
  203.     hdrstr = []
  204.     for v in hdr:
  205.         hdrstr.append(struct.pack('f', v))
  206.     
  207.     return hdrstr
  208.  
  209.  
  210. def _save(im, fp, filename):
  211.     if im.mode[0] != 'F':
  212.         im = im.convert('F')
  213.     
  214.     hdr = makeSpiderHeader(im)
  215.     if len(hdr) < 256:
  216.         raise IOError, 'Error creating Spider header'
  217.     len(hdr) < 256
  218.     
  219.     try:
  220.         fp = open(filename, 'wb')
  221.     except:
  222.         raise IOError, 'Unable to open %s for writing' % filename
  223.  
  224.     fp.writelines(hdr)
  225.     rawmode = 'F;32NF'
  226.     ImageFile._save(im, fp, [
  227.         ('raw', (0, 0) + im.size, 0, (rawmode, 0, 1))])
  228.     fp.close()
  229.  
  230.  
  231. def _save_spider(im, fp, filename):
  232.     (fn, ext) = os.path.splitext(filename)
  233.     Image.register_extension('SPIDER', ext)
  234.     _save(im, fp, filename)
  235.  
  236. Image.register_open('SPIDER', SpiderImageFile)
  237. Image.register_save('SPIDER', _save_spider)
  238. if __name__ == '__main__':
  239.     if not sys.argv[1:]:
  240.         print 'Syntax: python SpiderImagePlugin.py Spiderimage [outfile]'
  241.         sys.exit()
  242.     
  243.     filename = sys.argv[1]
  244.     if not isSpiderImage(filename):
  245.         print 'input image must be in Spider format'
  246.         sys.exit()
  247.     
  248.     outfile = ''
  249.     if len(sys.argv[1:]) > 1:
  250.         outfile = sys.argv[2]
  251.     
  252.     im = Image.open(filename)
  253.     print 'image: ' + str(im)
  254.     print 'format: ' + str(im.format)
  255.     print 'size: ' + str(im.size)
  256.     print 'mode: ' + str(im.mode)
  257.     print 'max, min: ', im.getextrema()
  258.     if outfile != '':
  259.         im = im.transpose(Image.FLIP_LEFT_RIGHT)
  260.         print 'saving a flipped version of %s as %s ' % (os.path.basename(filename), outfile)
  261.         im.save(outfile, 'SPIDER')
  262.     
  263.  
  264.