imageCls.py

#!/usr/bin/python3.6
# -*- coding: utf-8 -*-
import os
from sys import argv
import numpy
from PIL import Image, ImageOps, ImageDraw
from pillow_heif import register_heif_opener
import colorsys
from mediaCls import MediaFile, MediaFolder
import mediaCls as media
from kmeans import Kmeans, KmeansTablesNb
import loggerFct as log

imgExtensions =[ 'jpg', 'bmp', 'gif', 'png', 'mp4', 'avi', 'heic', 'heif' ]

numpy.seterr (all='warn')
rgb_to_hsv = numpy.vectorize (colorsys.rgb_to_hsv)
hsv_to_rgb = numpy.vectorize (colorsys.hsv_to_rgb)
register_heif_opener()

def creerGif (nomGif, gifFolder, imageNameList):
	if gifFolder[-1] != os.sep: gifFolder = gifFolder + os.sep
	nomGif = gifFolder + nomGif + '.gif'
	pilImageList =[]
	for imageName in imageNameList:
		pilImageList.append (Image.open (gifFolder + imageName))
		pilImageList[-1] = pilImageList[-1].convert ('RGB')
	imageRef = pilImageList.pop(0)
	imageRef.save (nomGif, save_all=True, append_images=pilImageList, duration=500, loop=0)

def blurrOne (table, y,x):
	# calculer la valeur moyenne
	neighbours =[]
	if y>0: neighbours.append (table[y-1][x])
	if y< (len (table) -1): neighbours.append (table[y+1][x])
	if x>0: neighbours.append (table[y][x-1])
	if x< (len (table[0]) -1): neighbours.append (table[y][x+1])
	n=0
	lenbours = len (neighbours)
	while n< lenbours and neighbours.count (neighbours[n]) <2: n+=1
	if n== lenbours: return neighbours[1]
	else: return neighbours[n]

def blurr (table):
	rangeX = range (len (table[0]))
	rangeY = range (len (table))
	for y in rangeY:
		for x in rangeX: table[y][x] = blurrOne (table, y,x)
	return table

# ------------------------ o ------------------------

class ImageFile (MediaFile):
	def __init__ (self, image=None):
		MediaFile.__init__ (self)
		self.image = None
		self.array =[]
		self.width =0
		self.height =0
		if image:
			self.path = image
			self.fromPath()

	def test (self):
		hue, saturation, brightness = self.toHsv()
		"""
		hue = 80
		saturation = 60
		brightness = 50
		"""
		hue = blurr (hue)
		saturation = 60
		brightness = 50
		hueKmeans = KmeansTablesCanal (hue)
		hueT = hue.T
		for group in hueKmeans.groups:
			for color in group[1:]:
				colorArea = (hueT == color)
			hue[hueT.T] = group[0]
		print (hue)
		self.fromHsv (hue, saturation, brightness)

	def heifToPng (self, nameSpace, addHour=False):
		# l'image fera 1000 pixel de haut
		dateCreation = media.getDateCreation (self.title +'.'+ self.extension, nameSpace, addHour)
		self.open()
		self.resizeHeight1000()
		self.correctContrast()
		nameCreation = media.createDatedName (self.pathRoot, 'png', dateCreation)
		if nameCreation:
			self.image.save (nameCreation)
			self.toPath()
			os.remove (self.path)

	def renameDate (self, nameSpace, addHour=False):
		""" renommer un fichier en prenant en compte la date
		la fonction utilise les métadonnées de window
		"""
		nameCreation = self.renameDateEtape1 (nameSpace, addHour);
		if nameCreation:
			self.resizeHeight1000()
			self.correctContrast()
			self.draw()
			os.rename (self.path, nameCreation)

	def resizeHeight1000 (self):
		heightNew =1000
		if self.image.size[1] > heightNew:
			percentScale = float (heightNew / float (self.image.size[1]))
			widthNew = int (self.image.size[0] * percentScale)
			self.image = self.image.resize ((widthNew, heightNew), Image.Resampling.LANCZOS)

	def eraseColors (self, referImg):
		# éffacer certaines couleurs d'une image à partir d'une image de référence qui les contient
		colors = referImg.getColors()
		self.array = numpy.array (self.image)
		red, green, blue = self.array.T
		"""
		self.array is a height x width x (r,g,b) numpy array
		red is a height x width x (0.0 ... 100) numpy array
		"""
		# éffacer les couleurs
		for r,g,b in colors:
			colorArea = (red == r) & (green == g) & (blue == b)
			self.array[colorArea.T] = (255, 255, 255)
		# dessiner la nouvelle image
		self.image = Image.fromarray (self.array)

	def reverseColors (self):
		self.image = ImageOps.invert (self.image)

	def reverseLumins (self):
		hue, saturation, brightness = self.toHsv()
		brightness = 100.0 - brightness
		self.fromHsv (hue, saturation, brightness)

	def reverseImage (self):
		self.reverseLumins()
		self.image = ImageOps.invert (self.image)

	def to16bits (self):
		self.image = self.image.convert ('P', colors=16)
	#	self.array = numpy.array (self.image)

	def tobw (self):
		self.image = ImageOps.grayscale (self.image)

	def swapColors (self, colOldStr, colNewStr):
		# colXStr = "30 67 23"
		colOld = colOldStr.split (" ")
		colOld[0] = int (colOld[0])
		colOld[1] = int (colOld[1])
		colOld[2] = int (colOld[2])
		colNew = colNewStr.split (" ")
		colNew[0] = int (colNew[0])
		colNew[1] = int (colNew[1])
		colNew[2] = int (colNew[2])
		self.array = numpy.array (self.image)
		red, green, blue = self.array.T
		colorArea = (red == colOld[0]) & (green == colOld[1]) & (blue == colOld[2])
		self.array[colorArea.T] = colNew
		self.image = Image.fromarray (self.array)

	def correctContrast (self):
		# calculer le contraste des couleurs. une valeur pas canal rvb
		colors = self.getColors()
		colMin =[ colors[0][0], colors[0][1], colors[0][2] ]
		colMax =[ colors[0][0], colors[0][1], colors[0][2] ]
		for color in colors:
			if color[0] < colMin[0]: colMin[0] = color[0]
			elif color[0] > colMax[0]: colMax[0] = color[0]
			if color[1] < colMin[1]: colMin[1] = color[1]
			elif color[1] > colMax[1]: colMax[1] = color[1]
			if color[2] < colMin[2]: colMin[2] = color[2]
			elif color[2] > colMax[2]: colMax[2] = color[2]
		colSpan =[ colMax[0] - colMin[0], colMax[1] - colMin[1], colMax[2] - colMin[2] ]
		self.array = numpy.array (self.image).astype ('float')
		rangeY = range (len (self.array))
		rangeX = range (len (self.array[0]))
		if colSpan[0] <200:
			factorA = 255.0 / colSpan[0]
			factorB = colMin[0] * factorA
			for y in rangeY:
				for x in rangeX: self.array[y][x][0] = factorA * self.array[y][x][0] - factorB
		if colSpan[1] <200:
			factorA = 255.0 / colSpan[1]
			factorB = colMin[1] * factorA
			for y in rangeY:
				for x in rangeX: self.array[y][x][1] = factorA * self.array[y][x][1] - factorB
		if colSpan[2] <200:
			factorA = 255.0 / colSpan[2]
			factorB = colMin[2] * factorA
			for y in rangeY:
				for x in rangeX: self.array[y][x][2] = factorA * self.array[y][x][2] - factorB
		self.array = self.array.astype ('uint8')
		self.image = Image.fromarray (self.array)

	def getColors (self):
		colorsOriginal = self.image.getcolors (self.image.size[0] * self.image.size[1])
		colorsSet = set (colorsOriginal)
		colors =[]
		for nb, color in colorsSet: colors.append (color)
		colors.sort()
		return colors

	def toHsv (self):
		"""
		hue is a height x width x (0.0 ... 1) numpy array
		saturation is a height x width x (0.0 ... 1) numpy array
		brightness is a height x width x (0.0 ... 256) numpy array
		je les normalise à 100
		"""
		self.array = numpy.array (self.image).astype ('float')
		red, green, blue = self.array.T
		hue, saturation, brightness = rgb_to_hsv (red, green, blue)
		hue *= 100.0
		saturation *= 100.0
		brightness *= 100.0
		brightness /= 255.0
		return hue, saturation, brightness

	def fromHsv (self, hue, saturation, brightness):
		hue /= 100.0
		saturation /= 100.0
		brightness *= 2.55
		red, green, blue = hsv_to_rgb (hue, saturation, brightness)
		red = red.T
		green = green.T
		blue = blue.T
		self.array = numpy.dstack ((red, green, blue))
		self.array = self.array.astype ('uint8')
		self.image = Image.fromarray (self.array)

	def fromArray (self):
		self.image = Image.fromarray (self.array)

	def toArray (self):
		self.array = numpy.array (self.image)

	def fromMedia (self, mediaFile):
		self.path = mediaFile.path
		self.title = mediaFile.title
		self.extension = mediaFile.extension
		self.pathRoot = mediaFile.pathRoot
		self.open()

	def setImage (self, imageNew):
		self.image = imageNew.convert ('RGB')
		self.width = self.image.size[0]
		self.height = self.image.size[1]

	def open (self):
		self.toPath()
		if not os.path.exists (self.path): return
		self.setImage (Image.open (self.path))

	def draw (self):
		isDrawable = MediaFile.draw (self)
		if isDrawable:
			if self.extension == 'heic' or self.extension == 'heif':
				print ('attention, vous avez faillit enregistrer une image heic')
			else: self.image.save (self.path)

class ImageFolder (MediaFolder):
	def test (self):
		self.path = 'b/cgi'
		self.get ('deborah')
		self.insta()

	def insta (self, drawBgfonc='average'):
		self.open()
		ratio = self.list[0].width / self.list[0].height
		ratioMin = ratio
		ratioMax = ratio
		for image in self.list:
			ratio = image.width / image.height
			if ratio < ratioMin: ratioMin = ratio
			elif ratio > ratioMax: ratioMax = ratio
		imageRange = range (len (self.list))
		if ratioMax <1.0:
			for i in imageRange:
				regrowMade = self.list[i].insta (drawBgfonc, ratioMax)
				if regrowMade:
					self.list[i].title = self.list[i].title +' insta'
					self.list[i].draw()
		elif ratioMin >1.0:
			for i in imageRange:
				regrowMade = self.list[i].insta (drawBgfonc, ratioMin)
				if regrowMade:
					self.list[i].title = self.list[i].title +' insta'
					self.list[i].draw()
		else:
			for i in imageRange:
				regrowMade = self.list[i].insta (drawBgfonc, 1.0)
				if regrowMade:
					self.list[i].title = self.list[i].title +' insta'
					self.list[i].draw()

	def heicToPng (self, addHour=False):
		nameSpace = media.getNameSpace (self.path[:-1])
		self.get ('heic')
		for image in self.list:
			if os.sep not in image.path:
				image.path = self.path + image.path
			image.heifToPng (nameSpace, addHour)

	def heifToPng (self, addHour=False):
		nameSpace = media.getNameSpace (self.path[:-1])
		self.get ('heif')
		for image in self.list:
			if os.sep not in image.path:
				image.path = self.path + image.path
				image.heifToPng (nameSpace, addHour)

	def open (self):
		imageRange = range (len (self.list))
		for i in imageRange: self.list[i].open()

	def get (self, detail=""):
		if detail == 'heic':
			for dirpath, SousListDossiers, subList in os.walk (self.path):
				if not subList: continue
				range_tag = range (len (subList) -1, -1, -1)
				for i in range_tag:
					if subList[i][-5:] != '.heic': trash = subList.pop(i)
				if subList:
					for image in subList:
						fileTmp = ImageFile (os.path.join (dirpath, image))
						self.list.append (fileTmp)
		elif detail == 'heif':
			for dirpath, SousListDossiers, subList in os.walk (self.path):
				if not subList: continue
				range_tag = range (len (subList) -1, -1, -1)
				for i in range_tag:
					if subList[i][-5:] != '.heif': trash = subList.pop(i)
				if subList:
					for image in subList:
						fileTmp = ImageFile (os.path.join (dirpath, image))
						self.list.append (fileTmp)
		else:
			MediaFolder.get (self, detail)
			imageRange = range (len (self.list))
			for i in imageRange:
				imageNew = ImageFile (self.list[i])
				self.list[i] = imageNew
		self.list.sort()

""" sources
https://www.geeksforgeeks.org/python-pil-image-point-method/
https://pillow.readthedocs.io/en/stable/reference/ImageOps.html
"""