erp5_safeimage: External Functions added

bt5/erp5_safeimage/ExtensionTemplateItem/ERP5SafeImage_Selenium.py

+import Image as PIL_Image
+import os
+import transaction
+from Products.ERP5Type.tests.ERP5TypeTestCase import ERP5TypeTestCase
+
+
+class FileUpload(file):
+  """Act as an uploaded file.
+  """
+  __allow_access_to_unprotected_subobjects__ = 1
+  def __init__(self, path, name):
+    self.filename = name
+    file.__init__(self, path)
+    self.headers = {}
+
+def makeFilePath(name):
+ # return os.path.join(os.path.dirname(__file__), 'tmp', name)
+  return name
+
+def makeFileUpload(name, as_name=None):
+  if as_name is None:
+    as_name = name
+  path = makeFilePath(name)
+  return FileUpload(path, as_name)
+
+
+def uploadImage(self):
+    portal = self.getPortalObject()
+    image = portal.restrictedTraverse('portal_skins/erp5_safeimage/img/image_test.jpg')
+    path_image = "tmp/selenium_image_test.jpg"
+    fd = os.open(path_image, os.O_CREAT | os.O_RDWR)
+    os.write(fd,str(image.data))
+    os.close(fd)
+    tile_image_transformed = makeFileUpload(path_image)
+    tile_transformed = self.image_module.newContent(portal_type='Image Tile Transformed',
+          title='testTileTransformed', id='testTileTransformed',
+          file=tile_image_transformed, filename='testTileTransformed')
+    if tile_transformed:
+      return True
+    else:
+      return False
+
+def cleanUp(self):
+    portal = self.getPortalObject()
+    print "exists path: %r" %os.path.exists("tmp/selenium_image_test.jpg")
+    if os.path.exists("tmp/selenium_image_test.jpg"):
+      print "REMOVE IMAGE: %s" %(os.remove("tmp/selenium_image_test.jpg"))
+      portal.image_module.manage_delObjects(ids=['testTileTransformed'])
+      return True
+    else:
+      return False

bt5/erp5_safeimage/ExtensionTemplateItem/ERP5ZoomifyImage.py

+##############################################################################
+# Copyright (C) 2005  Adam Smith  asmith@agile-software.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 2 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+##############################################################################
+
+import os, sys, shutil, tempfile
+import Image
+from cStringIO import StringIO
+from zLOG import LOG,ERROR,INFO,WARNING
+from OFS.Image import File, Image
+import os, transaction
+from AccessControl import getSecurityManager, ClassSecurityInfo
+from Globals import package_home
+import Image as PIL_Image
+import thread
+import random
+import base64
+from OFS.Folder import Folder 
+
+class ZoomifyBase:
+
+  _v_imageFilename = ''
+  format = ''
+  originalWidth = 0
+  originalHeight = 0
+  _v_scaleInfo = []
+  numberOfTiles = 0
+  _v_tileGroupMappings = {}
+  qualitySetting = 80
+  tileSize = 256
+  my_file = StringIO() 
+
+  def openImage(self):
+    """ load the image data """
+
+    pass
+    return
+
+  def getImageInfo(self):
+    """ """
+
+    image = self.openImage()
+    self.format = image.format
+    self.originalWidth, self.originalHeight = image.size
+    image = None
+    width, height = (self.originalWidth, self.originalHeight)
+    self._v_scaleInfo = [(width, height)]
+    while (width > self.tileSize) or (height > self.tileSize):
+      width, height = (width / 2, height / 2)
+      self._v_scaleInfo.insert(0, (width, height))
+    totalTiles=0
+    tier, rows, columns = (0,0,0)
+    for tierInfo in self._v_scaleInfo:
+      rows = height/self.tileSize
+      if height % self.tileSize > 0:
+        rows +=1
+      columns = width/self.tileSize
+      if width%self.tileSize > 0:
+        columns += 1
+      totalTiles += rows * columns
+      tier += 1
+
+  def getImageMetadata(self):
+    """ given an image name, load it and extract metadata """
+
+    image = self.openImage()
+    self.format = image.format
+    self.originalWidth, self.originalHeight = image.size
+    image = None
+    # get scaling information
+    width, height = (self.originalWidth, self.originalHeight)
+    self._v_scaleInfo = [(width, height)]
+    while (width > self.tileSize) or (height > self.tileSize):
+      width, height = (width / 2, height / 2)
+      self._v_scaleInfo.insert(0, (width, height))
+    # tile and tile group information
+    self.preProcess()
+    return
+
+  def createDataContainer(self, imageName):
+    """ create a container for tile groups and tile metadata """
+
+    pass
+    return
+
+  def getAssignedTileContainerName(self, tileFileName=None):
+    """ return the name of the tile group for the indicated tile """
+    if tileFileName:
+      if hasattr(self, '_v_tileGroupMappings') and self._v_tileGroupMappings:
+        containerName = self._v_tileGroupMappings.get(tileFileName, None)
+        if containerName:
+          return containerName
+    x = self.getNewTileContainerName()
+    return x
+
+  def getNewTileContainerName(self, tileGroupNumber=0):
+    """ return the name of the next tile group container """
+
+    return 'TileGroup' + str(tileGroupNumber)
+
+  def createTileContainer(self, tileContainerName=None):
+    """ create a container for the next group of tiles within the data container """
+
+    pass
+    return
+
+  def getTileFileName(self, scaleNumber, columnNumber, rowNumber):
+    """ get the name of the file the tile will be saved as """
+
+    return '%s-%s-%s.jpg' % (str(scaleNumber), str(columnNumber), str(rowNumber))
+
+  def getFileReference(self, scaleNumber, columnNumber, rowNumber):
+    """ get the full path of the file the tile will be saved as """
+
+    pass
+    return
+
+  def getNumberOfTiles(self):
+    """ get the number of tiles generated 
+        Should this be implemented as a safeguard, or just use the count of 
+        tiles gotten from processing? (This would make subclassing a little
+        easier.) """
+
+    return self.numberOfTiles
+
+  def getXMLOutput(self):
+    """ create xml metadata about the tiles """
+
+    numberOfTiles = self.getNumberOfTiles()
+    xmlOutput = '<IMAGE_PROPERTIES WIDTH="%s" HEIGHT="%s" NUMTILES="%s" NUMIMAGES="1" VERSION="1.8" TILESIZE="%s" />'
+    xmlOutput = xmlOutput % (str(self.originalWidth),
+            str(self.originalHeight), str(numberOfTiles), str(self.tileSize))
+    return xmlOutput
+
+  def saveXMLOutput(self):
+    """ save xml metadata about the tiles """
+
+    pass
+    return
+
+  def saveTile(self, image, scaleNumber, column, row):
+    """ save the cropped region """
+
+    pass
+    return
+
+  def processImage(self):
+    """ starting with the original image, start processing each row """
+    tier=(len(self._v_scaleInfo) -1)
+    row = 0
+    ul_y, lr_y = (0,0)
+    root, ext = os.path.splitext(self._v_imageFilename)
+    if not root:
+      root = self._v_imageFilename
+    ext = '.jpg'
+    image = self.openImage()
+    while row * self.tileSize < self.originalHeight:
+      ul_y = row * self.tileSize
+      if (ul_y + self.tileSize) < self.originalHeight:
+        lr_y = ul_y + self.tileSize
+      else:
+        lr_y = self.originalHeight
+      print "Going to open image"
+      imageRow = image.crop([0, ul_y, self.originalWidth, lr_y])
+      saveFilename = root + str(tier) + '-' + str(row) +  ext
+      if imageRow.mode != 'RGB':
+        imageRow = imageRow.convert('RGB')
+      imageRow.save(os.path.join(tempfile.gettempdir(), saveFilename),
+                                                        'JPEG', quality=100)
+      print "os path exist : %r" % os.path.exists(os.path.join(
+                                        tempfile.gettempdir(), saveFilename))
+      if os.path.exists(os.path.join(tempfile.gettempdir(), saveFilename)): 
+        self.processRowImage(tier=tier, row=row)
+      row += 1
+
+  def processRowImage(self, tier=0, row=0):
+    """ for an image, create and save tiles """
+
+    print '*** processing tier: ' + str(tier) + ' row: ' + str(row)
+    tierWidth, tierHeight = self._v_scaleInfo[tier]
+    rowsForTier = tierHeight/self.tileSize
+    if tierHeight % self.tileSize > 0:
+      rowsForTier +=1
+    root, ext = os.path.splitext(self._v_imageFilename)  
+    if not root:
+      root = self._v_imageFilename
+    ext = '.jpg'
+    imageRow = None
+    if tier == (len(self._v_scaleInfo) -1):
+      firstTierRowFile = root + str(tier) + '-' + str(row) + ext
+      if os.path.exists(os.path.join(tempfile.gettempdir(),firstTierRowFile)):
+        imageRow = PIL_Image.open(os.path.join(tempfile.gettempdir(), 
+                                                    firstTierRowFile))
+    else:
+      # create this row from previous tier's rows
+      imageRow = PIL_Image.new('RGB', (tierWidth, self.tileSize))
+      firstRowFile = root + str(tier+1) + '-' + str(row + row) + ext
+      firstRowWidth, firstRowHeight = (0,0)
+      secondRowWidth, secondRowHeight = (0,0)
+      if os.path.exists(os.path.join(tempfile.gettempdir(),firstRowFile)):
+        firstRowImage = PIL_Image.open(os.path.join(tempfile.gettempdir(),
+                                                         firstRowFile))
+        firstRowWidth, firstRowHeight = firstRowImage.size
+        imageRow.paste(firstRowImage, (0,0))
+        os.remove(os.path.join(tempfile.gettempdir(), firstRowFile))
+      secondRowFile = root + str(tier+1) + '-' + str(row + row +1) + ext
+      # there may not be a second row at the bottom of the image...
+      if os.path.exists(os.path.join(tempfile.gettempdir(), secondRowFile)):
+        secondRowImage = PIL_Image.open(os.path.join(tempfile.gettempdir(),
+                                                        secondRowFile))
+        secondRowWidth, secondRowHeight = secondRowImage.size
+        imageRow.paste(secondRowImage, (0, firstRowHeight))
+        os.remove(os.path.join(tempfile.gettempdir(), secondRowFile))
+      # the last row may be less than self.tileSize...
+      if (firstRowHeight + secondRowHeight) < (self.tileSize*2):
+        imageRow = imageRow.crop((0, 0, tierWidth,
+                               (firstRowHeight+secondRowHeight)))
+    if imageRow:
+      # cycle through columns, then rows
+      column = 0
+      imageWidth, imageHeight = imageRow.size
+      ul_x, ul_y, lr_x, lr_y = (0,0,0,0) # final crop coordinates
+      while not ((lr_x == imageWidth) and (lr_y == imageHeight)):
+        # set lower right cropping point
+        if (ul_x + self.tileSize) < imageWidth:
+          lr_x = ul_x + self.tileSize
+        else:
+          lr_x = imageWidth
+        if (ul_y + self.tileSize) < imageHeight:
+          lr_y = ul_y + self.tileSize
+        else:
+          lr_y = imageHeight
+        self.saveTile(imageRow.crop([ul_x, ul_y, lr_x, lr_y]), tier,
+                                                        column, row)
+        self.numberOfTiles += 1
+        # set upper left cropping point
+        if (lr_x == imageWidth):
+          ul_x=0
+          ul_y = lr_y
+          column = 0
+        else:
+          ul_x = lr_x
+          column += 1
+      if tier > 0:
+        # a bug was discovered when a row was exactly 1 pixel in height
+        # this extra checking accounts for that
+        if imageHeight > 1:
+          tempImage = imageRow.resize((imageWidth/2, imageHeight/2),
+                                                     PIL_Image.ANTIALIAS)
+          tempImage.save(os.path.join(tempfile.gettempdir(), root + str(tier)
+                                       + '-' + str(row) + ext))
+          tempImage = None
+      rowImage = None
+      if tier > 0:
+        if row % 2 != 0:
+          self.processRowImage(tier=(tier-1), row=((row-1)/2))
+        elif row == rowsForTier-1:
+          self.processRowImage(tier=(tier-1), row=(row/2))
+
+  def ZoomifyProcess(self, imageNames):
+    """ the method the client calls to generate zoomify metadata """
+
+    pass
+    return
+
+  def preProcess(self):
+    """ plan for the arrangement of the tile groups """
+
+    tier = 0
+    tileGroupNumber = 0
+    numberOfTiles = 0
+    for width, height in self._v_scaleInfo:
+      #cycle through columns, then rows
+      row, column = (0,0)
+      ul_x, ul_y, lr_x, lr_y = (0,0,0,0)  #final crop coordinates
+      while not ((lr_x == width) and (lr_y == height)):
+        tileFileName = self.getTileFileName(tier, column, row)
+        tileContainerName = self.getNewTileContainerName(
+                                        tileGroupNumber=tileGroupNumber)
+        if numberOfTiles ==0:
+          self.createTileContainer(tileContainerName=tileContainerName)
+        elif (numberOfTiles % self.tileSize) == 0:
+          tileGroupNumber += 1
+          tileContainerName = self.getNewTileContainerName(
+                                       tileGroupNumber=tileGroupNumber)
+          self.createTileContainer(tileContainerName=tileContainerName)
+        self._v_tileGroupMappings[tileFileName] = tileContainerName
+        numberOfTiles += 1
+        # for the next tile, set lower right cropping point
+        if (ul_x + self.tileSize) < width:
+          lr_x = ul_x + self.tileSize
+        else:
+          lr_x = width
+        if (ul_y + self.tileSize) < height:
+          lr_y = ul_y + self.tileSize
+        else:
+          lr_y = height
+        # for the next tile, set upper left cropping point
+        if (lr_x == width):
+          ul_x=0
+          ul_y = lr_y
+          column = 0
+          row += 1
+        else:
+          ul_x = lr_x
+          column += 1
+      tier += 1
+
+
+class ZoomifyZopeProcessor(ZoomifyBase):
+  """ basic functionality to provide Zoomify functionality inside Zope """
+
+  _v_imageObject = None
+  _v_saveFolderObject = None
+  _v_transactionCount = 0
+  security = ClassSecurityInfo()
+  security.declareObjectProtected('Add Documents, Images, and Files')
+
+  def openImage(self):
+    """ load the image data """
+
+    return PIL_Image.open(self._v_imageObject.name)
+
+  def createDefaultViewer(self):
+    """ add the default Zoomify viewer to the Zoomify metadata """
+
+    # also, add the default zoomifyViewer here if a zoomify viewer is acquirable
+    # (could this be done a better way, like using the 'web methods' 
+    # approach that points to ZMI screens that are DTML or ZPT files
+    # in the product package)?
+    if not hasattr(self._v_saveFolderObject, 'default_ZoomifyViewer'):
+      defaultViewerPath = os.path.join(package_home(globals()), 'www',
+                                                  'zoomifyViewer.swf')
+      if os.path.isfile(defaultViewerPath):
+        fileContent = open(defaultViewerPath).read()
+        self._v_saveFolderObject._setObject('default_ZoomifyViewer', 
+                               File('default_ZoomifyViewer', '', fileContent, 
+                                    'application/x-shockwave-flash', ''))
+    transaction.savepoint()
+    return
+
+  def createDataContainer(self):
+    """ create a folder that contains all the tiles of the image """
+
+    self._v_saveToLocation = str(self._v_imageObject.getId()) + '_data'
+    parent = self._v_imageObject.aq_parent
+    if hasattr(parent, self._v_saveToLocation):
+      # allow for tiles to be updated from a changed image
+      parent._delObject(self._v_saveToLocation)
+    if not hasattr(parent, self._v_saveToLocation):
+      newFolder = Folder()
+      newFolder.id = self._v_saveToLocation
+      parent._setObject(self._v_saveToLocation, newFolder)
+    self._v_saveFolderObject = parent[self._v_saveToLocation]
+    transaction.savepoint()
+    return
+
+  def createTileContainer(self, tileContainerName=None):
+    """ create a container for the next group of tiles within the data container """ 
+
+    if hasattr(self._v_saveFolderObject, tileContainerName):
+      # allow for tiles to be updated from a changed image
+      self._v_saveFolderObject._delObject(tileContainerName)
+    if not hasattr(self._v_saveFolderObject, tileContainerName):
+      newFolder = Folder()
+      newFolder.id = tileContainerName
+      self._v_saveFolderObject._setObject(tileContainerName, newFolder)
+    transaction.savepoint()
+    return
+
+  def getNumberOfTiles(self):
+    """ get the number of tiles generated 
+        Should this be implemented as a safeguard, or just use the count of 
+        tiles gotten from processing? (This would make subclassing a little
+        easier.) """
+    return self.numberOfTiles
+
+  def saveXMLOutput(self):
+    """ save xml metadata about the tiles """
+
+    if hasattr(self._v_saveFolderObject, 'ImageProperties.xml'):
+      # allow file to be updated from a changed image, regenerated tiles
+      self._v_saveFolderObject._delObject('ImageProperties.xml')
+    self._v_saveFolderObject._setObject('ImageProperties.xml', 
+                        File('ImageProperties.xml', '', self.getXMLOutput(), 
+                             'text/xml', ''))
+    transaction.savepoint()
+    return
+
+  def saveTile(self, image, scaleNumber, column, row):
+    """ save the cropped region """
+
+    w,h = image.size
+    if w != 0 and h != 0:
+      tileFileName = self.getTileFileName(scaleNumber, column, row)
+      tileContainerName = self.getAssignedTileContainerName(
+                                          tileFileName=tileFileName)
+      tileImageData = StringIO()
+      image.save(tileImageData, 'JPEG', quality=self.qualitySetting)
+      tileImageData.seek(0)
+      if hasattr(self._v_saveFolderObject, tileContainerName):
+        tileFolder = getattr(self._v_saveFolderObject, tileContainerName)
+        # if an image of this name already exists, delete and replace it.
+        if hasattr(tileFolder, tileFileName):
+          tileFolder._delObject(tileFileName)
+        # finally, save the image data as a Zope Image object
+        tileFolder._setObject(tileFileName, Image(tileFileName, '', 
+                                              '', 'image/jpeg', ''))
+        tileFolder._getOb(tileFileName).manage_upload(tileImageData)
+      self._v_transactionCount += 1
+      if self._v_transactionCount % 10 == 0:
+        transaction.savepoint()
+    return
+
+  def encrypto(self):
+    if self.transformed:
+      # def encrypto(self,message='Attack at dawn'):
+      #   """encrypto each thing"""
+      #   key ='abcdefghijklmnop'
+      #   iv = Random.new().read(AES.block_size)
+      #   EncodeIV = lambda : base64.b64encode(iv)
+      #   EncodeAES = lambda c, s: base64.b64encode(c.encrypt(message))
+      #   IVcoded  = EncodeIV()
+      #   cipher = AES.new(key,AES.MODE_CFB,iv)
+      #   msg  = EncodeAES(cipher,key)
+      #   return msg    
+      pass
+    else:
+      pass
+    return
+
+  def _process(self):
+    """ the actual zoomify processing workflow """
+
+    self.createDataContainer()
+    self.createDefaultViewer()
+    self.openImage()
+    self.getImageMetadata()
+    self.processImage()
+    self.saveTransformedFile()
+    self.saveXMLOutput()
+    self.encrypto()
+    return
+
+  def saveTransformedFile(self):
+    pass
+    return
+
+  def _ZoomifyProcess(self):
+    """ factored out ZODB connection handling """
+
+    #import Zope
+    #app = Zope.app()
+    #get_transaction().begin()
+    self._process()
+    #app._p_jar.close()
+    #del app
+    return
+
+  security.declareProtected('Add Documents, Images, and Files', 'ZoomifyProcess')
+  def ZoomifyProcess(self, id, imageObject=None):
+    """ factored out threading of process (removed for now) """
+    if imageObject:
+      self._v_imageObject = imageObject
+      self._v_imageFilename = id
+      self._ZoomifyProcess()
+    return
+
+class ERP5ZoomifyZopeProcessor(ZoomifyZopeProcessor):
+
+  def __init__(self, document,transformed=None):
+     self.document = document
+     self.transformed = transformed
+     self.count = 0 
+
+  def createTileContainer(self, tileContainerName=None):
+    """ create each TileGroup """
+
+    self.document.newContent(portal_type="Image Tile Group", 
+                   title=tileContainerName, id=tileContainerName, 
+                   filename=tileContainerName)
+    return 
+
+  def createDefaultViewer(self):
+    """ add the default Zoomify viewer to the Zoomify metadata """
+    pass
+    return
+
+  def createDataContainer(self, imageName="None"):
+    """Creates nothing coz we are already in the container"""
+    pass
+    return
+
+  def _updateTransformedFile(self,tile_group_id,tile_title):
+    """create and save the transform file"""
+    num = random.choice([0,1])
+    while num >= 0: 
+      algorithm = random.choice(['sepia','brightness','noise','lighten',
+                                  'posterize','edge','none'])
+      if algorithm == 'lighten':
+        param1 = random.choice([-0.6,-0.5,-0.4,-0.3,-0.2,-0.1,0.1,0.2,
+                                 0.3,0.4,0.5,0.6])
+        param2 = 0
+      elif algorithm == 'posterize':
+        param1 = random.choice([4,5,6,7,8,9,10,11,12,13,14,15,16,17,
+                                18,19,20,21])
+        param2 = 0
+      elif algorithm == 'brightness':
+        param1 = random.choice([-80,-60,-40,-20,20,40,60,80])
+        param2 = random.choice([-0.3,-0.2,-0.1,0,0.1,0.5,0.9])
+      else:
+        param1 = 0
+        param2 = 0
+      my_text = '%s %s %s %s %s %s \n' %(tile_group_id, tile_title, 
+                                    algorithm, param1, param2, num)
+      self.my_file.write(my_text)
+      num = num - 1
+
+
+  def saveTile(self, image, scaleNumber, column,row):
+    """save the cropped region"""
+    tileFileName = self.getTileFileName(scaleNumber, column, row)
+    tileContainerName = self.getAssignedTileContainerName(
+                                       tileFileName=tileFileName)
+    namesplit = tileFileName.split('.')
+    w,h = image.size
+    if w != 0 and h !=0:
+      tile_group_id = self.getAssignedTileContainerName()
+      tile_group=self.document[tile_group_id]
+      tileImageData= StringIO()
+      image.save(tileImageData, 'JPEG', quality=self.qualitySetting)
+      tileImageData.seek(0)
+      if tile_group is None:
+        raise AttributeError('unable to fine tile group %r' % tile_group_id)
+      w = tile_group.newContent(portal_type='Image', title=namesplit[0],
+                 id=namesplit[0], file=tileImageData, filename=namesplit[0])
+      if self.transformed:
+        self._updateTransformedFile(tile_group_id, namesplit[0])
+    return
+
+  def saveXMLOutput(self):
+    """save the xml file"""
+    my_string = StringIO()
+    my_string.write(self.getXMLOutput())
+    my_string.seek(0)
+    self.document.newContent(portal_type='Embedded File',
+                             id='ImageProperties.xml', file=my_string,
+                             filename='ImageProperties.xml')
+    return
+
+  def saveTransformedFile(self):
+    """add in Zope the transform file """
+    if self.transformed:
+      self.my_file.seek(0)
+      self.document.newContent(portal_type='Embedded File',
+                             id='TransformFile.txt', file=self.my_file,
+                             filename='TransformFile.txt')
+    return
+
+
+def getERP5ZoomifyProcessor(document,transformed=False):
+  return ERP5ZoomifyZopeProcessor(document,transformed)
+

bt5/erp5_safeimage/bt/revision

-10
+11
\ No newline at end of file

bt5/erp5_safeimage/bt/template_extension_id_list

+ERP5SafeImage_Selenium
+ERP5ZoomifyImage
\ No newline at end of file