# -*- coding: utf-8 -*-
#######################################################################################
#   Plinn - http://plinn.org                                                          #
#   Copyright © 2009  Benoît Pin <pin@cri.ensmp.fr>                                   #
#                                                                                     #
#   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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.   #
#######################################################################################
""" PPM File support module



"""

from subprocess import Popen, PIPE
from tempfile import TemporaryFile
import os
from math import ceil
from PIL.Image import open as imgopen
from PIL.Image import fromstring
from PIL.Image import ANTIALIAS
from cStringIO import StringIO

DGJPEG = 'djpeg'
RESIZING_TILE_SIZE = 1024

class PPMFile(object) :
	
	def __init__(self, f, tileSize=256, isRaw=False) :
		# convert jpeg -> ppm with djpeg
		if not isRaw :
			# print 'djpeg'
			self.fp = TemporaryFile(mode='w+')
			p = Popen(DGJPEG, stdin=f, stdout=self.fp, stderr=PIPE, shell=True)
			p.wait()
			err = p.stderr.read()
			if err :
				raise SystemError, err
		else :
			self.fp = f
		
		# get image specs with PIL
		self.fp.seek(0)
		im = imgopen(self.fp)
		decoder, region, offset, parameters = im.tile[0]
		x, y, width, height = region
		del im
		assert decoder == 'raw'
		mode = parameters[0]
		assert mode in ('RGB', 'L'), "Unsupported mode %s" % mode

		if mode == 'RGB' :
			sampleSize = 3
		elif mode == 'L' :
			sampleSize = 1
		
		self.width = width
		self.height = height
		self.offset = offset
		self.mode = parameters[0]
		self.sampleSize = sampleSize
		self._setTileSize(tileSize)
	
	def _setTileSize(self, tileSize) :
		self.tileSize = tileSize
		self.tilesX = int(ceil(float(self.width) / self.tileSize))
		self.tilesY = int(ceil(float(self.height) / self.tileSize))
	
	def getTile(self, xt, yt) :
		f = self.fp
		ss = self.sampleSize
		x = xt * self.tileSize
		y = yt * self.tileSize
		start = (self.width * y + x) * ss + self.offset
		
		tw = th = self.tileSize

		bw = self.width - x
		if bw < self.tileSize  :
			tw = bw
		bh = self.height - y
		if bh < self.tileSize :
			th = bh
		
		assert tw > 0 and th > 0, "Tile requested out of image."

		size = (tw, th)
		tll = tw * ss
		jump = (self.width - tw) * ss
		
		f.seek(start)
		data = StringIO()
		
		for line in xrange(size[1]) :
			data.write(f.read(tll))
			f.seek(jump, 1)
		
		data.seek(0)
		im = fromstring(self.mode, size, data.read())
		return im
	
	def getTileSequence(self):
		seq = []
		for y in xrange(self.tilesY) :
			for x in xrange(self.tilesX) :
				seq.append((x, y))
		return seq
	
	def resize(self, ratio=None, maxLength=None) :
		if ratio and maxLength :
			raise AttributeError("'ratio' and 'size' are mutually exclusive.")
		if maxLength :
			maxFullLength = max(self.width, self.height)
			ratio = float(maxLength) / maxFullLength

		tileSizeBak = self.tileSize
		
		self._setTileSize(RESIZING_TILE_SIZE)
		
		width = height = 0
		# cumul des arrondis
		width = int(round(self.tileSize * ratio)) * (self.tilesX -1)
		width += int(round((self.width - self.tileSize * (self.tilesX -1)) * ratio))
		
		height = int(round(self.tileSize * ratio)) * (self.tilesY -1)
		height += int(round((self.height - self.tileSize * (self.tilesY -1)) * ratio))
		
		magic = self.mode == 'RGB' and 6 or 5
		head = 'P%d %d %d 255\n' % (magic, width, height)
		offset = len(head)

		out = TemporaryFile(mode='w+')
		out.write(head)

		ss = self.sampleSize
		rTll = int(round(self.tileSize * ratio))
		
		for x, y in self.getTileSequence() :
			# print 'resize', (x,y)
			tile = self.getTile(x,y)
			tileSize = tile.size
			size = map(lambda l : int(round(l * ratio)), tileSize)
			
			if size[0] and size[1] :
				resized = tile.resize(size, ANTIALIAS)
				data = resized.tostring()
				
				start = (y * width + x) * ss * rTll + offset
				jump = (width - size[0]) * ss
				
				out.seek(start)
				tll = size[0] * ss
				
				# écriture dans le bon ordre (c'est quand même plus agréable à l'œil)
				for l in xrange(size[1]) :
					lineData = data[l*tll:(l+1)*tll]
					out.write(lineData)
					out.seek(jump, 1)
		
		out.seek(0,2)
		length = out.tell()
		assert length - len(head) == width * height * ss, (length - len(head), width * height * ss)
		out.seek(0)

		self._setTileSize(tileSizeBak)
		return PPMFile(out, tileSize=tileSizeBak, isRaw=True)
	
	def getImage(self) :
		self.fp.seek(0)
		return imgopen(self.fp)
	
	def __del__(self) :
		self.fp.close()


if __name__ == '__main__' :
	f = open('/Users/pinbe/Desktop/Chauve_souris.jpg')
	try :
		ppm = PPMFile(f, tileSize=256)
		rppm = ppm.resize(maxLength=800)
		im = rppm.getImage()
		im.show()
		for x, y in ppm.getTileSequence() :
			im = ppm.getTile(x, y)
			im.save('testoutput/%d_%d.jpg' % (x, y), 'JPEG', quality=90)
	finally :
		f.close()