Return to ImageArchive.py CVS log

Up to [Repository] / ImageArchive

bug fixed in thumbnail display

from OFS.Folder import Folder
from OFS.SimpleItem import SimpleItem
from Globals import Persistent
from Acquisition import Implicit
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
from Products.PageTemplates.PageTemplate import PageTemplate
import re
import os
import os.path
import urllib
import xml.dom.minidom

def getText(nodelist):
    
    rc = ""
    for node in nodelist:
    
    	if node.nodeType == node.TEXT_NODE:
           rc = rc + node.data
    return rc


class ImageDigilib(Folder,Persistent,Implicit):
    """Anzeige object fuer digilib"""
    meta_type="ImageDigilib"

    leiden_meta_fields=['image_id','date','country','place','people','description','photographer']

    manage_options = Folder.manage_options+(
        
        {'label':'Add Metadata','action':'addMetaObjectForm'},
        
        )

    def addMetaObject(self,id,RESPONSE=None):
        """Add an MetaObject"""
        objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)

        request=self.REQUEST
        objectCreate=objectType.createObjectManager(id,request)
        #for field in self.leiden_meta_fields:
        #    self.REQUEST[field]=argv[field]
        self._setObject(id,objectCreate)
        
        objectCreate.propertysheets.meta.manage_editProperties(request)

        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

        


    def addMetaObjectForm(self):
        """Add Form"""
        pt=PageTemplateFile('Products/ImageArchive/addMetaObject.zpt').__of__(self)
        return pt()        


    def __init__(self,id,filename,meta=None):
        self.id=id
        self.title=filename
        self.filename=filename
        self.meta=meta

            
    
    def getMeta(self):
        """ausgabe der metadaten"""
        return self.meta
    
    def uploadImage(self,fileupload,path_name):
        """upload an Image from an Requast"""
        #path_name=self.ImageStoragePath
        filename=path_name+"/"+fileupload.filename
        filedata=fileupload.read()
        f=open(filename,"w")
        f.write(filedata)
        f.close()
        os.chmod(filename,0644)
        os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 100 &"% self.ImageViewerPath)

    

    
        
    def download(self):
        """download"""
        path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&mo=rawfile,highres"
        #self.REQUEST.SESSION['string']="<img src=\"%s\">"% path
        #pt=PageTemplateFile('Products/ImageArchive/thumb.zpt').__of__(self)
        return self.REQUEST.RESPONSE.redirect(path)
    
    def thumb(self):
        """show thumb"""
        thumbname=os.path.splitext(self.filename)[0]+".jpg"
        ## if not os.path.exists("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname):
##             image=urllib.urlopen("http://nausikaa2.rz-berlin.mpg.de:18080/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&dw=150&mo=lores").read()
##             f=open("/mpiwg/temp/online/scaled/small/"+self.ImageViewerPath+"/"+thumbname,"w")
##             f.write(image)
##             f.close()
##             os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 150 &"% self.ImageViewerPath)
            
        #DEVEL:take nausikaa for server solution
        
        path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/servlet/Scaler/?fn="+self.ImageViewerPath+"/"+self.filename+"&dw=100&dh=100&mo=lores"
        #path="/mpiwg/online/"+self.ImageViewerPath+"/"+thumbname
        self.REQUEST.SESSION['string']="<img border=\"0\" src=\"%s\">"% path
        pt=PageTemplateFile('Products/ImageArchive/thumb.zpt').__of__(self)
        return pt()
    
    def index_html(self):
        """show image"""
        #DEVELOP: take first one for server
        
        path="http://nausikaa2.rz-berlin.mpg.de/digitallibrary/digilib.jsp?fn="+self.ImageViewerPath+"/"+self.filename

        #path="http://localhost:8080/mpiwg/online/"+self.ImageViewerPath+"/"+self.filename
        #self.REQUEST.SESSION['string']="<img src=\"%s\">"% path
        #pt=PageTemplateFile('Products/ImageArchive/thumb.zpt').__of__(self)
        return self.REQUEST.RESPONSE.redirect(path)

    
def manage_AddImageDigilibForm(self):
    """Nothing yet"""
    pt=PageTemplateFile('Products/ImageArchive/AddImageDigilibForm.zpt').__of__(self)
    return pt()
    
def manage_AddImageDigilib(self,id,fileupload,meta=None,RESPONSE=None):
    """Add ImageCollection"""
    #fileupload=self.REQUEST['fileupload']
    newObj=ImageDigilib(id,fileupload.filename,meta)
    
    self._setObject(id,newObj)
    getattr(self,id).uploadImage(fileupload,self.ImageStoragePath)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')

                 
class ImageCollection(Folder, Persistent, Implicit):
    """Sammelordner für Bilder"""
    meta_type="ImageCollection"

    genericMetaDataType="leiden_meta"

    leiden_meta_fields=['image_id','date','country','place','people','description','photographer']

    
    defaultMetaString="http://fm-web.mpiwg-berlin.mpg.de:8050/FMRes/FMPJS?-db=Wissenschaftlerportraits.fp5&-layID=69&-token=25&-max=1&-format=formvwcss.htm&-mode=browse&images::filename=%s&-find" ## TEST FUER IMAGEDATENBANK WP

    def scaleThumbs(self):
        """scale thumbs"""
        os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 100 &"% self.ImageViewerPath)
        return "RESCALING STARTED"
    
    def __init__(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString):
        self.id=id
        self.title=title
        self.ImageStoragePath=ImageStoragePath
        self.ImageViewerPath=ImageViewerPath
        self.defaultMetaString=defaultMetaString

    manage_options = Folder.manage_options+(
        {'label':'Main Config','action':'ImageCollection_config'},
        {'label':'Import','action':'ImportFiles'},
        {'label':'Recalculate Metadata','action':'recalculateMeta'},
        {'label':'Import Metadata','action':'importMetaForm'},
        {'label':'Rescale thumbs','action':'scaleThumbs'},
        )


    def importMetaForm(self):
        """import metadata"""
        pt=PageTemplateFile('Products/ImageArchive/importMeta.zpt').__of__(self)
        return pt()

    def importMeta(self,fileupload,tag):
        """import"""
        filedata=fileupload.read()
        dom=xml.dom.minidom.parseString(filedata)
        rows=dom.getElementsByTagName(tag)
        #print "ROWS",rows
        request=self.REQUEST
        for row in rows:
            
            for a in self.leiden_meta_fields:
                self.REQUEST[a]=getText(row.getElementsByTagName(a)[0].childNodes)

            image_id=self.REQUEST['image_id']
            if (not hasattr(self,image_id)) & (not image_id==""):
                #print image_id
                newObj=ImageCollection(str(image_id),image_id,'','','')
                self._setObject(str(image_id),newObj)

            id="leiden_meta_data_file"
            self.REQUEST['id']=id
            #objectType=getattr(self.Control_Panel.Products.ImageMetaData,self.genericMetaDataType)
            #objectCreate=objectType.createInObjectManager(id,request)
            #href="http://localhost:8080/tests/testcollection/manage_addProduct/ImageMetaData/leiden_meta_factory/"
            try:
                addID=getattr(self,image_id)
                objectCreate=addID.manage_addProduct['ImageMetaData'].leiden_meta_add(id)
                #getattr(self,image_id)._setObject(id,objectCreate)
                obj=getattr(addID,id)
                obj.propertysheets.meta.manage_editProperties(request)
            except:
                """nothing"""
        return "OK"
    

    def nextImage(self,request,selected=None):
        """show nextimage"""
        try:
            ids=self.show_thumbs()
            if request.SESSION.has_key("filename"):
                filename=request.SESSION["filename"]
                try:
                    nr=ids.index(filename)
                except:
                    nr=0
            else:
                nr=0

            if nr==len(ids)-1:
                return ""
            else:
                if selected:
                    return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr+1]+"\" target=\"_top\">next image</a>"
                else:
                    return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr+1]+"\" target=\"_top\">next image</a>"
        except:
            return ""
        
    def prevImage(self,request,selected=None):
        """show nextimage"""
        #return self.getId()
        try:
            ids=self.show_thumbs()
            if request.SESSION.has_key("filename"):
                filename=request.SESSION["filename"]
                try:
                    nr=ids.index(filename)
                except:
                    nr=0
            else:
                nr=0

            if nr==0:
                return ""
            else:
                if selected:
                    return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr-1]+"\" target=\"_top\">previous image</a>"
                else:
                    return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr-1]+"\" target=\"_top\">previous image</a>"
        except:
            return ""
        
    def meta_default(self,filename):
        """url der metadaten"""
        return self.defaultMetaString % filename
                     
    def getThumbAttribute(self,id,attr):
        if hasattr(self,id):
            return getattr(getattr(self,id),attr)
        else:
            if attr=='title':
                return "<b>Missing Image:%s</b>" % id

    def getThumbFunction(self,id,attr):
        #return "DUMP"
        if hasattr(self,id):
            return getattr(getattr(self,id),attr)()
        
            
    def xmlinput(self,url):
        """Anzeige von ausgewaehlten thumbs"""
        #return url
        
        url=urllib.unquote(url)
        xmldoc=urllib.urlopen(url).read()
        #print url
        dom=xml.dom.minidom.parseString(xmldoc)
        
        images=dom.getElementsByTagName('imagename')
        rc=[]
        for image in images:
            text=getText(image.childNodes)
            if not text=="":
                rc.append(str(text))
        rc.sort()
        self.REQUEST.SESSION['filenames']=rc
        pt=PageTemplateFile('Products/ImageArchive/overview_selected.zpt').__of__(self)
        return pt()        

    def recalculateMeta(self):
        """recalculate the metadata"""
        
        for entryid in self.__dict__:
            entry=getattr(self,entryid)
            if hasattr(entry,'meta_type'):
                
                if entry.meta_type=="ImageDigilib":
                    entry.meta=entry.meta_default(entry.getId())
        return "OK"
    
    def addImage(self):
        """Add an Image"""
        pt=PageTemplateFile('Products/ImageArchive/addImage.zpt').__of__(self)
        return pt()
    
    def addImage2(self,fileupload,meta,use_default=None,RESPONSE=None):
        """Add"""
        #print "FU",fileupload

        if use_default:
            try:
                meta=self.meta_default(fileupload.filename)
            except:
                meta=None
        else:
            meta=None
                
        manage_AddImageDigilib(self,fileupload.filename,fileupload,meta=meta)
        return RESPONSE.redirect(self.REQUEST['URL1']+'/'+fileupload.filename)
        #return  self.REQUEST['URL1']+'/'+fileupload.filename

    def ImportFiles2(self,RESPONSE=None):
        """Import the existing files of a folder"""
        files=os.listdir(self.ImageStoragePath)
        ret=""
        #print self.__dict__
        for file in files:
            if not file[0]==".":
                if self.__dict__.has_key(file):

                    ret=ret+"<br>"+file+" already exists!"
                else:
                    ret=ret+"<br>"+file+" created!"
                    meta=self.meta_default(file)
                    newObj=ImageDigilib(file,file,meta)
                    #print newObj,file
                    #print newObj
                    self._setObject(file,newObj)
        #print ret
        #pt=PageTemplateFile('Products/ImageArchive/out.zpt').__of__(self)
        #print self.ImageStoragePath
        os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 100 &"% self.ImageViewerPath)
        RESPONSE.redirect('manage_main')
    
    def ImportFiles(self,RESPONSE=None):
        """Import the existing files of a folder"""
        files=os.listdir(self.ImageStoragePath)
        ret=""
        #print self.__dict__
        for file in files:
            if not file[0]==".":
                if self.__dict__.has_key(file):

                    ret=ret+"<br>"+file+" already exists!"
                else:
                    ret=ret+"<br>"+file+" created!"
                    newObj=ImageDigilib(file,file)
                    #print newObj,file
                    #print newObj
                    try:
                        self._setObject(file,newObj)
                    except:
                        """nothing yet"""
        #print ret
        #pt=PageTemplateFile('Products/ImageArchive/out.zpt').__of__(self)
        #print self.ImageStoragePath
        os.popen("ssh nausikaa2.rz-berlin.mpg.de /usr/local/mpiwg/scripts/scaleomat.pl %s /mpiwg/temp/online/scaled/small 100 &"% self.ImageViewerPath)
        RESPONSE.redirect('manage_main')
        
    def ImageCollection_config(self):
        """Nothing yet"""
        if not hasattr(self,'defaultMetaString'):
            self.defaultMetaString=""
            
        pt=PageTemplateFile('Products/ImageArchive/ChangeImageCollectionForm.zpt').__of__(self)
        return pt()

    def ChangeImageCollection(self,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
        """Change"""
        self.title=title
        self.ImageStoragePath=ImageStoragePath
        self.ImageViewerPath=ImageViewerPath
        self.defaultMetaString=defaultMetaString
        
        if RESPONSE is not None:
            RESPONSE.redirect('manage_main')

    def show_selected_thumbs(self):
        #ids=[]
        
        return self.REQUEST.SESSION['filenames']

    def show_thumbs(self):
        ids=[]
        for entry in self.__dict__:
            #print entry
            if hasattr(getattr(self,entry),'thumb'):
                ids.append(entry)
                
        #print ids
        ids.sort()
        return ids

    def firstSets(self,selected=None):
        ids=self.show_thumbs()
        if ids:
            if selected:
                return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[0]+"\" target=\"_top\">first sets</a>"
            else:
                return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[0]+"\" target=\"_top\">first sets</a>"

    def lastSets(self,selected=None):
        ids=self.show_thumbs()
        if ids:
            colRows=self.getColTimesRow()

            if colRows[1]:
                nr=len(ids)-colRows[0]*colRows[1]
            else:
                nr=0

            if nr<0:
                nr=0

            if selected:
                return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">last set</a>"
            else:
                return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">last sets</a>"

        
                
    def nextSets(self,selected=None):
        """show nextimage"""
        ids=self.show_thumbs()
        colRows=self.getColTimesRow()
        if ids:
            if colRows[1]:

                if self.REQUEST.SESSION.has_key("filename"):
                    filename=self.REQUEST.SESSION["filename"]
                    try:
                        nr=ids.index(filename)+colRows[0]*colRows[1]
                        if nr>=len(ids):
                            nr=len(ids)-1
                    except:
                        nr=0
                else:
                    nr=0

                if nr==len(ids)-1:
                    return ""
                else:
                    if selected:
                        return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">next set</a>"
                    else:
                        return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">next set</a>"

    def prevSets(self,selected=None):
        
        """show nextimage"""
        #return self.getId()
        ids=self.show_thumbs()
        colRows=self.getColTimesRow()
        if ids:
            if colRows[1]:
                if self.REQUEST.SESSION.has_key("filename"):
                    filename=self.REQUEST.SESSION["filename"]
                    try:
                        nr=ids.index(filename)-colRows[0]*colRows[1]
                        if nr<0:
                            nr=0
                    except:
                        nr=0
                else:
                    nr=0
                try:
                    num=ids.index(filename)
                except:
                    num=0

                if num==0:
                    return ""
                else:
                    if selected:
                        return "<a href=\""+self.REQUEST['URL1']+"/selection?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"
                    else:
                        return "<a href=\""+self.REQUEST['URL1']+"?filename="+ids[nr]+"\" target=\"_top\">previous sets</a>"
            else:
                return ""
            
    def show_thumbs_selected_rows(self,numberOfColumns):
        """Ausgabe anzahl"""
        ids=self.show_selected_thumbs()
        self.REQUEST.SESSION['ids']=ids
        number=int(len(ids)/numberOfColumns)+1
        self.REQUEST.SESSION['number']=range(number)
        return range(number+1)

    def setColTimesRowForm(self):
        """form for matrix setting"""
        pt=PageTemplateFile('Products/ImageArchive/selectColTimesRow.zpt').__of__(self)
        return pt()

    def setDone(self):
        """done"""
        
        pt=PageTemplateFile('Products/ImageArchive/changedColTimesRow.zpt').__of__(self)
        return pt()

    def setColTimesRow(self,cols,rows):
        """set coltimes row"""
        RESPONSE=self.REQUEST.RESPONSE
        if not rows:
            rows=None
        if rows=="":
            rows=None

        if rows=="all":
            rows=None
        

        if rows:
            RESPONSE.setCookie("ImageViewerRows",rows)
        else:
            RESPONSE.expireCookie("ImageViewerRows")
        RESPONSE.setCookie("ImageViewerCols",cols)

        RESPONSE.redirect(self.REQUEST['URL1']+"/setDone")
        
    def getColTimesRow(self):
        """coltimesrow"""
        
        REQUEST=self.REQUEST
        """matrix"""
        if REQUEST.cookies.has_key("ImageViewerRows"):
            
            try:
                rows=int(REQUEST.cookies["ImageViewerRows"])
            except:
                rows=None
        else:
            rows=None
            
        if REQUEST.cookies.has_key("ImageViewerCols"):
            #print "COLS",REQUEST.cookies["ImageViewerCols"]
            cols=int(REQUEST.cookies["ImageViewerCols"])
        else:
            cols=3

        idsnumber=len(self.show_thumbs())
        if rows:
            if cols*rows >idsnumber:
                rows=int(idsnumber/cols)+1
        return (cols,rows)
                
        
    def show_thumbs_rows(self,numberOfColumns,numberOfRows=None,startId=None):
        """Ausgabe anzahl"""

        idsAll=self.show_thumbs()
        
        if self.REQUEST.SESSION.has_key("filename"):
            filename=self.REQUEST.SESSION["filename"]
            try:
                startId=filename
            except:
                startId=idsAll[0]
        else:
            startId=idsAll[0]
            

        print "NOR:",numberOfRows

        if numberOfRows:
            try:
                startPic=idsAll.index(startId)
                endPic=startPic+numberOfColumns*numberOfRows
                ids=idsAll[startPic:endPic]
            except:
                ids=idsAll
        else:
            ids=idsAll

            
        self.REQUEST.SESSION['ids']=ids
        number=int(len(ids)/numberOfColumns)+1
        
        return range(number+1)

    def show_thumbs_columns(self,row,numberOfColumns):
        """Ausgabe einer Liste der Reihe"""
        ids=self.REQUEST.SESSION['ids']
        max=len(ids)
        if (row*numberOfColumns)<max:
            return ids[(row-1)*numberOfColumns:row*numberOfColumns]
        else:
            return ids[(row-1)*numberOfColumns:]
        
    def thumblistSelected_old(self):
        """main template collection"""
        pt=PageTemplateFile('Products/ImageArchive/thumbselected.zpt').__of__(self)
        return pt()

    def thumblistSelected(self):
        """main template collection"""
        pt=PageTemplateFile('Products/ImageArchive/thumbselected2.zpt').__of__(self)
        return pt()
    
    def thumblist_old(self):
        """main template collection"""
        pt=PageTemplateFile('Products/ImageArchive/thumbs.zpt').__of__(self)
        return pt()

    def thumblist(self):
        """main template collection"""
        pt=PageTemplateFile('Products/ImageArchive/thumb2.zpt').__of__(self)
        return pt()

    def navig_selected_html(self):
        """navigation"""
        #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
        pt=PageTemplateFile('Products/ImageArchive/navigation_selected.zpt').__of__(self)
        return pt()

    def navig_html(self):
        """navigation"""
        #self.REQUEST.SESSION['URL']=self.REQUEST['URL0']
        pt=PageTemplateFile('Products/ImageArchive/navigation.zpt').__of__(self)
        return pt()


    def selection(self):
        """show only selected"""
        if self.REQUEST.has_key('filename'):
            filen=self.REQUEST['filename']
        else:
            filen=""
        self.REQUEST.SESSION['filename']=filen
        pt=PageTemplateFile('Products/ImageArchive/overview_selected2.zpt').__of__(self)
        return pt()  
        
    def index_html(self):
        """main template collection"""
        if self.REQUEST.has_key('filename'):
            filen=self.REQUEST['filename']
        else:
            filen=""
        self.REQUEST.SESSION['filename']=filen
        pt=PageTemplateFile('Products/ImageArchive/overview.zpt').__of__(self)
        return pt()
    
def manage_AddImageCollectionForm(self):
    """Nothing yet"""
    pt=PageTemplateFile('Products/ImageArchive/AddImageCollectionForm.zpt').__of__(self)
    return pt()
    
def manage_AddImageCollection(self,id,title,ImageStoragePath,ImageViewerPath,defaultMetaString,RESPONSE=None):
    """Add ImageCollection"""
    newObj=ImageCollection(id,title,ImageStoragePath,ImageViewerPath,defaultMetaString)
    self._setObject(id,newObj)
    
    if RESPONSE is not None:
        RESPONSE.redirect('manage_main')