# ##### BEGIN GPL LICENSE BLOCK #####
#
#  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.
#
# ##### END GPL LICENSE BLOCK #####

#  Filename : shaders.py
#  Authors  : Fredo Durand, Stephane Grabli, Francois Sillion, Emmanuel Turquin 
#  Date     : 11/08/2005
#  Purpose  : Stroke shaders to be used for creation of stylized strokes

from freestyle import AdjacencyIterator, Curvature2DAngleF0D, DensityF0D, GetProjectedZF0D, \
    Interface0DIterator, MaterialF0D, Nature, Noise, Normal2DF0D, Orientation2DF1D, \
    StrokeAttribute, StrokeShader, StrokeVertexIterator, ZDiscontinuityF0D
from freestyle import ContextFunctions as CF
from PredicatesU0D import pyVertexNatureUP0D

import math
import mathutils
import random

## thickness modifiers
######################

class pyDepthDiscontinuityThicknessShader(StrokeShader):
	def __init__(self, min, max):
		StrokeShader.__init__(self)
		self.__min = float(min)
		self.__max = float(max)
		self.__func = ZDiscontinuityF0D()
	def shade(self, stroke):
		z_min=0.0
		z_max=1.0
		a = (self.__max - self.__min)/(z_max-z_min)
		b = (self.__min*z_max-self.__max*z_min)/(z_max-z_min)
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			z = self.__func(Interface0DIterator(it))
			thickness = a*z+b
			it.object.attribute.thickness = (thickness, thickness)
			it.increment()

class pyConstantThicknessShader(StrokeShader):
	def __init__(self, thickness):
		StrokeShader.__init__(self)
		self._thickness = thickness
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			t = self._thickness/2.0
			it.object.attribute.thickness = (t, t)
			it.increment()

class pyFXSVaryingThicknessWithDensityShader(StrokeShader):
	def __init__(self, wsize, threshold_min, threshold_max, thicknessMin, thicknessMax):
		StrokeShader.__init__(self)
		self.wsize= wsize
		self.threshold_min= threshold_min
		self.threshold_max= threshold_max
		self._thicknessMin = thicknessMin
		self._thicknessMax = thicknessMax
	def shade(self, stroke):
		n = stroke.stroke_vertices_size()
		i = 0
		it = stroke.stroke_vertices_begin()
		func = DensityF0D(self.wsize)
		while not it.is_end:
			c = func(Interface0DIterator(it))
			if c < self.threshold_min:
				c = self.threshold_min
			if c > self.threshold_max:
				c = self.threshold_max
##			t = (c - self.threshold_min)/(self.threshold_max - self.threshold_min)*(self._thicknessMax-self._thicknessMin) + self._thicknessMin
			t = (self.threshold_max - c  )/(self.threshold_max - self.threshold_min)*(self._thicknessMax-self._thicknessMin) + self._thicknessMin
			it.object.attribute.thickness = (t/2.0, t/2.0)
			i = i+1
			it.increment()

class pyIncreasingThicknessShader(StrokeShader):
	def __init__(self, thicknessMin, thicknessMax):
		StrokeShader.__init__(self)
		self._thicknessMin = thicknessMin
		self._thicknessMax = thicknessMax
	def shade(self, stroke):
		n = stroke.stroke_vertices_size()
		i = 0
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			c = float(i)/float(n)
			if i < float(n)/2.0:
				t = (1.0 - c)*self._thicknessMin + c * self._thicknessMax
			else:
				t = (1.0 - c)*self._thicknessMax + c * self._thicknessMin
			it.object.attribute.thickness = (t/2.0, t/2.0)
			i = i+1
			it.increment()

class pyConstrainedIncreasingThicknessShader(StrokeShader):
	def __init__(self, thicknessMin, thicknessMax, ratio):
		StrokeShader.__init__(self)
		self._thicknessMin = thicknessMin
		self._thicknessMax = thicknessMax
		self._ratio = ratio
	def shade(self, stroke):
		slength = stroke.length_2d
		tmp = self._ratio*slength
		maxT = 0.0
		if tmp < self._thicknessMax:
			maxT = tmp
		else:
			maxT = self._thicknessMax
		n = stroke.stroke_vertices_size()
		i = 0
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			att = it.object.attribute
			c = float(i)/float(n)
			if i < float(n)/2.0:
				t = (1.0 - c)*self._thicknessMin + c * maxT
			else:
				t = (1.0 - c)*maxT + c * self._thicknessMin
			att.thickness = (t/2.0, t/2.0)
			if i == n-1:
				att.thickness = (self._thicknessMin/2.0, self._thicknessMin/2.0)
			i = i+1
			it.increment()

class pyDecreasingThicknessShader(StrokeShader):
	def __init__(self, thicknessMin, thicknessMax):
		StrokeShader.__init__(self)
		self._thicknessMin = thicknessMin
		self._thicknessMax = thicknessMax
	def shade(self, stroke):
		l = stroke.length_2d
		tMax = self._thicknessMax
		if self._thicknessMax > 0.33*l:
			tMax = 0.33*l
		tMin = self._thicknessMin
		if self._thicknessMin > 0.1*l:
			tMin = 0.1*l
		n = stroke.stroke_vertices_size()
		i = 0
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			c = float(i)/float(n)
			t = (1.0 - c)*tMax +c*tMin
			it.object.attribute.thickness = (t/2.0, t/2.0)
			i = i+1
			it.increment()

class pyNonLinearVaryingThicknessShader(StrokeShader):
	def __init__(self, thicknessExtremity, thicknessMiddle, exponent):
		StrokeShader.__init__(self)
		self._thicknessMin = thicknessMiddle
		self._thicknessMax = thicknessExtremity
		self._exponent = exponent
	def shade(self, stroke):
		n = stroke.stroke_vertices_size()
		i = 0
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			if i < float(n)/2.0:
				c = float(i)/float(n)
			else:
				c = float(n-i)/float(n)
			c = self.smoothC(c, self._exponent)
			t = (1.0 - c)*self._thicknessMax + c * self._thicknessMin
			it.object.attribute.thickness = (t/2.0, t/2.0)
			i = i+1
			it.increment()
	def smoothC(self, a, exp):
		return math.pow(float(a), exp) * math.pow(2.0, exp)

## Spherical linear interpolation (cos)
class pySLERPThicknessShader(StrokeShader):
	def __init__(self, thicknessMin, thicknessMax, omega=1.2):
		StrokeShader.__init__(self)
		self._thicknessMin = thicknessMin
		self._thicknessMax = thicknessMax
		self._omega = omega
	def shade(self, stroke):
		slength = stroke.length_2d
		tmp = 0.33*slength
		maxT = self._thicknessMax
		if tmp < self._thicknessMax:
			maxT = tmp
		n = stroke.stroke_vertices_size()
		i = 0
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			c = float(i)/float(n)
			if i < float(n)/2.0:
				t = math.sin((1-c)*self._omega)/math.sinh(self._omega)*self._thicknessMin + math.sin(c*self._omega)/math.sinh(self._omega) * maxT
			else:
				t = math.sin((1-c)*self._omega)/math.sinh(self._omega)*maxT + math.sin(c*self._omega)/math.sinh(self._omega) * self._thicknessMin
			it.object.attribute.thickness = (t/2.0, t/2.0)
			i = i+1
			it.increment()

class pyTVertexThickenerShader(StrokeShader): ## FIXME
	def __init__(self, a=1.5, n=3):
		StrokeShader.__init__(self)
		self._a = a
		self._n = n
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		predTVertex = pyVertexNatureUP0D(Nature.T_VERTEX)
		while not it.is_end:
			if predTVertex(it) == 1:
				it2 = StrokeVertexIterator(it)
				it2.increment()
				if not (it.is_begin or it2.is_end):
					it.increment()
					continue
				n = self._n
				a = self._a
				if it.is_begin:
					it3 = StrokeVertexIterator(it)
					count = 0
					while (not it3.is_end) and count < n:
						att = it3.object.attribute
						(tr, tl) = att.thickness
						r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1
						#r = (1.0-a)/float(n-1)*count + a
						att.thickness = (r*tr, r*tl)	
						it3.increment()
						count = count + 1
				if it2.is_end:
					it4 = StrokeVertexIterator(it)
					count = 0
					while (not it4.is_begin) and count < n:
						att = it4.object.attribute
						(tr, tl) = att.thickness
						r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1
						#r = (1.0-a)/float(n-1)*count + a
						att.thickness = (r*tr, r*tl)	
						it4.decrement()
						count = count + 1
					if it4.is_begin:
						att = it4.object.attribute
						(tr, tl) = att.thickness
						r = (a-1.0)/float(n-1)*(float(n)/float(count+1) - 1) + 1
						#r = (1.0-a)/float(n-1)*count + a
						att.thickness = (r*tr, r*tl)	
			it.increment()

class pyImportance2DThicknessShader(StrokeShader):
	def __init__(self, x, y, w, kmin, kmax):
		StrokeShader.__init__(self)
		self._x = x
		self._y = y
		self._w = float(w)
		self._kmin = float(kmin)
		self._kmax = float(kmax)
	def shade(self, stroke):
		origin = mathutils.Vector([self._x, self._y])
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			v = it.object
			p = mathutils.Vector([v.projected_x, v.projected_y])
			d = (p-origin).length
			if d > self._w:
				k = self._kmin
			else:
				k = (self._kmax*(self._w-d) + self._kmin*d)/self._w
			att = v.attribute
			(tr, tl) = att.thickness
			att.thickness = (k*tr/2.0, k*tl/2.0)
			it.increment()

class pyImportance3DThicknessShader(StrokeShader):
	def __init__(self, x, y, z, w, kmin, kmax):
		StrokeShader.__init__(self)
		self._x = x
		self._y = y
		self._z = z
		self._w = float(w)
		self._kmin = float(kmin)
		self._kmax = float(kmax)
	def shade(self, stroke):
		origin = mathutils.Vector([self._x, self._y, self._z])
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			v = it.object
			p = v.point_3d
			d = (p-origin).length
			if d > self._w:
				k = self._kmin
			else:
				k = (self._kmax*(self._w-d) + self._kmin*d)/self._w
			att = v.attribute
			(tr, tl) = att.thickness
			att.thickness = (k*tr/2.0, k*tl/2.0)
			it.increment()

class pyZDependingThicknessShader(StrokeShader):
	def __init__(self, min, max):
		StrokeShader.__init__(self)
		self.__min = min
		self.__max = max
		self.__func = GetProjectedZF0D()
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		z_min = 1
		z_max = 0
		while not it.is_end:
			z = self.__func(Interface0DIterator(it))
			if z < z_min:
				z_min = z
			if z > z_max:
				z_max = z
			it.increment()
		z_diff = 1 / (z_max - z_min)
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			z = (self.__func(Interface0DIterator(it)) - z_min) * z_diff
			thickness = (1 - z) * self.__max + z * self.__min
			it.object.attribute.thickness = (thickness, thickness)
			it.increment()


## color modifiers
##################

class pyConstantColorShader(StrokeShader):
	def __init__(self,r,g,b, a = 1):
		StrokeShader.__init__(self)
		self._r = r
		self._g = g
		self._b = b
		self._a = a
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			att = it.object.attribute
			att.color = (self._r, self._g, self._b)
			att.alpha = self._a
			it.increment()

#c1->c2
class pyIncreasingColorShader(StrokeShader):
	def __init__(self,r1,g1,b1,a1, r2,g2,b2,a2):
		StrokeShader.__init__(self)
		self._c1 = [r1,g1,b1,a1]
		self._c2 = [r2,g2,b2,a2]
	def shade(self, stroke):
		n = stroke.stroke_vertices_size() - 1
		inc = 0
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			att = it.object.attribute
			c = float(inc)/float(n)

			att.color = ((1-c)*self._c1[0] + c*self._c2[0], 
				     (1-c)*self._c1[1] + c*self._c2[1],
				     (1-c)*self._c1[2] + c*self._c2[2])
			att.alpha = (1-c)*self._c1[3] + c*self._c2[3]
			inc = inc+1
			it.increment()

# c1->c2->c1
class pyInterpolateColorShader(StrokeShader):
	def __init__(self,r1,g1,b1,a1, r2,g2,b2,a2):
		StrokeShader.__init__(self)
		self._c1 = [r1,g1,b1,a1]
		self._c2 = [r2,g2,b2,a2]
	def shade(self, stroke):
		n = stroke.stroke_vertices_size() - 1
		inc = 0
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			att = it.object.attribute
			u = float(inc)/float(n)
			c = 1-2*(math.fabs(u-0.5))
			att.color = ((1-c)*self._c1[0] + c*self._c2[0], 
				     (1-c)*self._c1[1] + c*self._c2[1],
				     (1-c)*self._c1[2] + c*self._c2[2])
			att.alpha = (1-c)*self._c1[3] + c*self._c2[3]
			inc = inc+1
			it.increment()

class pyMaterialColorShader(StrokeShader):
	def __init__(self, threshold=50):
		StrokeShader.__init__(self)
		self._threshold = threshold
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		func = MaterialF0D()
		xn = 0.312713
		yn = 0.329016
		Yn = 1.0
		un = 4.* xn/ ( -2.*xn + 12.*yn + 3. )
		vn= 9.* yn/ ( -2.*xn + 12.*yn +3. )	
		while not it.is_end:
			mat = func(Interface0DIterator(it))
			
			r = mat.diffuse[0]
			g = mat.diffuse[1]
			b = mat.diffuse[2]

			X = 0.412453*r + 0.35758 *g + 0.180423*b
			Y = 0.212671*r + 0.71516 *g + 0.072169*b
			Z = 0.019334*r + 0.119193*g + 0.950227*b

			if X == 0 and Y == 0 and Z == 0:
				X = 0.01
				Y = 0.01
				Z = 0.01
			u = 4.*X / (X + 15.*Y + 3.*Z)
			v = 9.*Y / (X + 15.*Y + 3.*Z)
			
			L= 116. * math.pow((Y/Yn),(1./3.)) -16
			U = 13. * L * (u - un)
			V = 13. * L * (v - vn)
			
			if L > self._threshold:
				L = L/1.3
				U = U+10
			else:
				L = L +2.5*(100-L)/5.
				U = U/3.0
				V = V/3.0				
			u = U / (13. * L) + un
			v = V / (13. * L) + vn
			
			Y = Yn * math.pow( ((L+16.)/116.), 3.)
			X = -9. * Y * u / ((u - 4.)* v - u * v)
			Z = (9. * Y - 15*v*Y - v*X) /( 3. * v)
			
			r = 3.240479 * X - 1.53715 * Y - 0.498535 * Z
			g = -0.969256 * X + 1.875991 * Y + 0.041556 * Z
			b = 0.055648 * X - 0.204043 * Y + 1.057311 * Z

			r = max(0,r)
			g = max(0,g)
			b = max(0,b)

			it.object.attribute.color = (r, g, b)
			it.increment()

class pyRandomColorShader(StrokeShader):
	def __init__(self, s=1):
		StrokeShader.__init__(self)
		random.seed(s)
	def shade(self, stroke):
		## pick a random color
		c0 = float(random.uniform(15,75))/100.0
		c1 = float(random.uniform(15,75))/100.0
		c2 = float(random.uniform(15,75))/100.0
		print(c0, c1, c2)
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			it.object.attribute.color = (c0,c1,c2)
			it.increment()

class py2DCurvatureColorShader(StrokeShader):
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		func = Curvature2DAngleF0D()
		while not it.is_end:
			c = func(Interface0DIterator(it))
			if c < 0:
				print("negative 2D curvature")
			color = 10.0 * c/3.1415
			it.object.attribute.color = (color, color, color)
			it.increment()

class pyTimeColorShader(StrokeShader):
	def __init__(self, step=0.01):
		StrokeShader.__init__(self)
		self._t = 0
		self._step = step
	def shade(self, stroke):
		c = self._t*1.0
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			it.object.attribute.color = (c,c,c)
			it.increment()
		self._t = self._t+self._step

## geometry modifiers

class pySamplingShader(StrokeShader):
	def __init__(self, sampling):
		StrokeShader.__init__(self)
		self._sampling = sampling
	def shade(self, stroke):
		stroke.resample(float(self._sampling)) 
		stroke.update_length()

class pyBackboneStretcherShader(StrokeShader):
	def __init__(self, l):
		StrokeShader.__init__(self)
		self._l = l
	def shade(self, stroke):
		it0 = stroke.stroke_vertices_begin()
		it1 = StrokeVertexIterator(it0)
		it1.increment()
		itn = stroke.stroke_vertices_end()
		itn.decrement()
		itn_1 = StrokeVertexIterator(itn)
		itn_1.decrement()
		v0 = it0.object
		v1 = it1.object
		vn_1 = itn_1.object
		vn = itn.object
		p0 = mathutils.Vector([v0.projected_x, v0.projected_y])
		pn = mathutils.Vector([vn.projected_x, vn.projected_y])
		p1 = mathutils.Vector([v1.projected_x, v1.projected_y])
		pn_1 = mathutils.Vector([vn_1.projected_x, vn_1.projected_y])
		d1 = p0-p1
		d1.normalize()
		dn = pn-pn_1
		dn.normalize()
		newFirst = p0+d1*float(self._l)
		newLast = pn+dn*float(self._l)
		v0.point = newFirst
		vn.point = newLast
		stroke.update_length()
		
class pyLengthDependingBackboneStretcherShader(StrokeShader):
	def __init__(self, l):
		StrokeShader.__init__(self)
		self._l = l
	def shade(self, stroke):
		l = stroke.length_2d
		stretch = self._l*l 
		it0 = stroke.stroke_vertices_begin()
		it1 = StrokeVertexIterator(it0)
		it1.increment()
		itn = stroke.stroke_vertices_end()
		itn.decrement()
		itn_1 = StrokeVertexIterator(itn)
		itn_1.decrement()
		v0 = it0.object
		v1 = it1.object
		vn_1 = itn_1.object
		vn = itn.object
		p0 = mathutils.Vector([v0.projected_x, v0.projected_y])
		pn = mathutils.Vector([vn.projected_x, vn.projected_y])
		p1 = mathutils.Vector([v1.projected_x, v1.projected_y])
		pn_1 = mathutils.Vector([vn_1.projected_x, vn_1.projected_y])
		d1 = p0-p1
		d1.normalize()
		dn = pn-pn_1
		dn.normalize()
		newFirst = p0+d1*float(stretch)
		newLast = pn+dn*float(stretch)
		v0.point = newFirst
		vn.point = newLast
		stroke.update_length()


## Shader to replace a stroke by its corresponding tangent
class pyGuidingLineShader(StrokeShader):
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin() 	## get the first vertex
		itlast = stroke.stroke_vertices_end() 	## 
		itlast.decrement()			## get the last one
		t = itlast.object.point - it.object.point	## tangent direction
		itmiddle = StrokeVertexIterator(it)	## 
		while itmiddle.object.u < 0.5:	## look for the stroke middle vertex
			itmiddle.increment()		##
		it = StrokeVertexIterator(itmiddle)	
		it.increment()
		while not it.is_end:			## position all the vertices along the tangent for the right part
			it.object.point = itmiddle.object.point \
			    +t*(it.object.u-itmiddle.object.u)
			it.increment()
		it = StrokeVertexIterator(itmiddle)
		it.decrement()
		while not it.is_begin:			## position all the vertices along the tangent for the left part
			it.object.point = itmiddle.object.point \
			    -t*(itmiddle.object.u-it.object.u)
			it.decrement()
		it.object.point = itmiddle.object.point-t*itmiddle.object.u ## first vertex
		stroke.update_length()


class pyBackboneStretcherNoCuspShader(StrokeShader):
	def __init__(self, l):
		StrokeShader.__init__(self)
		self._l = l
	def shade(self, stroke):
		it0 = stroke.stroke_vertices_begin()
		it1 = StrokeVertexIterator(it0)
		it1.increment()
		itn = stroke.stroke_vertices_end()
		itn.decrement()
		itn_1 = StrokeVertexIterator(itn)
		itn_1.decrement()
		v0 = it0.object
		v1 = it1.object
		if (v0.nature & Nature.CUSP) == 0 and (v1.nature & Nature.CUSP) == 0:
			p0 = v0.point
			p1 = v1.point
			d1 = p0-p1
			d1.normalize()
			newFirst = p0+d1*float(self._l)
			v0.point = newFirst
		vn_1 = itn_1.object
		vn = itn.object
		if (vn.nature & Nature.CUSP) == 0 and (vn_1.nature & Nature.CUSP) == 0:
			pn = vn.point
			pn_1 = vn_1.point
			dn = pn-pn_1
			dn.normalize()
			newLast = pn+dn*float(self._l)	
			vn.point = newLast
		stroke.update_length()

class pyDiffusion2Shader(StrokeShader):
	"""This shader iteratively adds an offset to the position of each
	stroke vertex in the direction perpendicular to the stroke direction
	at the point.  The offset is scaled by the 2D curvature (i.e., how
	quickly the stroke curve is) at the point."""
	def __init__(self, lambda1, nbIter):
		StrokeShader.__init__(self)
		self._lambda = lambda1
		self._nbIter = nbIter
		self._normalInfo = Normal2DF0D()
		self._curvatureInfo = Curvature2DAngleF0D()
	def shade(self, stroke):
		for i in range (1, self._nbIter):
			it = stroke.stroke_vertices_begin()
			while not it.is_end:
				v = it.object
				p1 = v.point
				p2 = self._normalInfo(Interface0DIterator(it))*self._lambda*self._curvatureInfo(Interface0DIterator(it))
				v.point = p1+p2
				it.increment()
		stroke.update_length()

class pyTipRemoverShader(StrokeShader):
	def __init__(self, l):
		StrokeShader.__init__(self)
		self._l = l
	def shade(self, stroke):
		originalSize = stroke.stroke_vertices_size()
		if originalSize < 4:
			return
		verticesToRemove = []
		oldAttributes = []
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			v = it.object
			if v.curvilinear_abscissa < self._l or v.stroke_length-v.curvilinear_abscissa < self._l:
				verticesToRemove.append(v)
			oldAttributes.append(StrokeAttribute(v.attribute))
			it.increment()
		if originalSize-len(verticesToRemove) < 2:
			return
		for sv in verticesToRemove:
			stroke.remove_vertex(sv)
		stroke.update_length()
		stroke.resample(originalSize)
		if stroke.stroke_vertices_size() != originalSize:
			print("pyTipRemover: Warning: resampling problem")
		it = stroke.stroke_vertices_begin()
		for a in oldAttributes:
			if it.is_end:
				break
			it.object.attribute = a
			it.increment()
		stroke.update_length()

class pyTVertexRemoverShader(StrokeShader):
	def shade(self, stroke):
		if stroke.stroke_vertices_size() <= 3:
			return
		predTVertex = pyVertexNatureUP0D(Nature.T_VERTEX)
		it = stroke.stroke_vertices_begin()
		itlast = stroke.stroke_vertices_end()
		itlast.decrement()
		if predTVertex(it):
			stroke.remove_vertex(it.object)
		if predTVertex(itlast):
			stroke.remove_vertex(itlast.object)
		stroke.update_length()

#class pyExtremitiesOrientationShader(StrokeShader):
#	def __init__(self, x1,y1,x2=0,y2=0):
#		StrokeShader.__init__(self)
#		self._v1 = mathutils.Vector([x1,y1])
#		self._v2 = mathutils.Vector([x2,y2])
#	def shade(self, stroke):
#		#print(self._v1.x,self._v1.y)
#		stroke.setBeginningOrientation(self._v1.x,self._v1.y)
#		stroke.setEndingOrientation(self._v2.x,self._v2.y)

class pyHLRShader(StrokeShader):
	def shade(self, stroke):
		originalSize = stroke.stroke_vertices_size()
		if originalSize < 4:
			return
		it = stroke.stroke_vertices_begin()
		invisible = 0
		it2 = StrokeVertexIterator(it)
		it2.increment()
		fe = self.get_fedge(it.object, it2.object)
		if fe.viewedge.qi != 0:
			invisible = 1
		while not it2.is_end:
			v = it.object
			vnext = it2.object
			if (v.nature & Nature.VIEW_VERTEX) != 0:
				#if (v.nature & Nature.T_VERTEX) != 0:
				fe = self.get_fedge(v, vnext)
				qi = fe.viewedge.qi
				if qi != 0:
					invisible = 1
				else:
					invisible = 0
			if invisible:
				v.attribute.visible = False
			it.increment()
			it2.increment()
	def get_fedge(self, it1, it2):
		return it1.get_fedge(it2)

class pyTVertexOrientationShader(StrokeShader):
	def __init__(self):
		StrokeShader.__init__(self)
		self._Get2dDirection = Orientation2DF1D()
	## finds the TVertex orientation from the TVertex and 
	## the previous or next edge
	def findOrientation(self, tv, ve):
		mateVE = tv.get_mate(ve)
		if ve.qi != 0 or mateVE.qi != 0:
			ait = AdjacencyIterator(tv,1,0)
			winner = None
			incoming = True
			while not ait.is_end:
				ave = ait.object
				if  ave.id != ve.id and ave.id != mateVE.id:
					winner = ait.object
					if not ait.isIncoming(): # FIXME
						incoming = False
						break
				ait.increment()
			if winner is not None:
				if not incoming:
					direction = self._Get2dDirection(winner.last_fedge)
				else:
					direction = self._Get2dDirection(winner.first_fedge)
				return direction
		return None
	def castToTVertex(self, cp):
		if cp.t2d() == 0.0:
			return cp.first_svertex.viewvertex
		elif cp.t2d() == 1.0:
			return cp.second_svertex.viewvertex
		return None
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		it2 = StrokeVertexIterator(it)
		it2.increment()
		## case where the first vertex is a TVertex
		v = it.object
		if (v.nature & Nature.T_VERTEX) != 0:
			tv = self.castToTVertex(v)
			if tv is not None:
				ve = self.get_fedge(v, it2.object).viewedge
				dir = self.findOrientation(tv, ve)
				if dir is not None:
					#print(dir.x, dir.y)
					v.attribute.set_attribute_vec2("orientation", dir)
		while not it2.is_end:
			vprevious = it.object
			v = it2.object
			if (v.nature & Nature.T_VERTEX) != 0:
				tv = self.castToTVertex(v)
				if tv is not None:
					ve = self.get_fedge(vprevious, v).viewedge
					dir = self.findOrientation(tv, ve)
					if dir is not None:
						#print(dir.x, dir.y)
						v.attribute.set_attribute_vec2("orientation", dir)
			it.increment()
			it2.increment()
		## case where the last vertex is a TVertex
		v = it.object 
		if (v.nature & Nature.T_VERTEX) != 0:
			itPrevious = StrokeVertexIterator(it)
			itPrevious.decrement()
			tv = self.castToTVertex(v)
			if tv is not None:
				ve = self.get_fedge(itPrevious.object, v).viewedge
				dir = self.findOrientation(tv, ve)
				if dir is not None:
					#print(dir.x, dir.y)
					v.attribute.set_attribute_vec2("orientation", dir)
	def get_fedge(self, it1, it2):
		return it1.get_fedge(it2)

class pySinusDisplacementShader(StrokeShader):
	def __init__(self, f, a):
		StrokeShader.__init__(self)
		self._f = f
		self._a = a
		self._getNormal = Normal2DF0D()
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			v = it.object
			#print(self._getNormal.name)
			n = self._getNormal(Interface0DIterator(it))
			p = v.point
			u = v.u
			a = self._a*(1-2*(math.fabs(u-0.5)))
			n = n*a*math.cos(self._f*u*6.28)
			#print(n.x, n.y)
			v.point = p+n
			#v.point = v.point+n*a*math.cos(f*v.u)
			it.increment()
		stroke.update_length()

class pyPerlinNoise1DShader(StrokeShader):
	def __init__(self, freq = 10, amp = 10, oct = 4, seed = -1):
		StrokeShader.__init__(self)
		self.__noise = Noise(seed)
		self.__freq = freq
		self.__amp = amp
		self.__oct = oct
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			v = it.object
			i = v.projected_x + v.projected_y
			nres = self.__noise.turbulence1(i, self.__freq, self.__amp, self.__oct)
			v.point = (v.projected_x + nres, v.projected_y + nres)
			it.increment()
		stroke.update_length()

class pyPerlinNoise2DShader(StrokeShader):
	def __init__(self, freq = 10, amp = 10, oct = 4, seed = -1):
		StrokeShader.__init__(self)
		self.__noise = Noise(seed)
		self.__freq = freq
		self.__amp = amp
		self.__oct = oct
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			v = it.object
			vec = mathutils.Vector([v.projected_x, v.projected_y])
			nres = self.__noise.turbulence2(vec, self.__freq, self.__amp, self.__oct)
			v.point = (v.projected_x + nres, v.projected_y + nres)
			it.increment()
		stroke.update_length()

class pyBluePrintCirclesShader(StrokeShader):
	def __init__(self, turns = 1, random_radius = 3, random_center = 5):
		StrokeShader.__init__(self)
		self.__turns = turns
		self.__random_center = random_center
		self.__random_radius = random_radius
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		if it.is_end:
			return
		p_min = it.object.point.copy()
		p_max = it.object.point.copy()
		while not it.is_end:
			p = it.object.point
			if p.x < p_min.x:
				p_min.x = p.x
			if p.x > p_max.x:
				p_max.x = p.x
			if p.y < p_min.y:
				p_min.y = p.y
			if p.y > p_max.y:
				p_max.y = p.y
			it.increment()
		stroke.resample(32 * self.__turns)
		sv_nb = stroke.stroke_vertices_size()
#		print("min  :", p_min.x, p_min.y) # DEBUG
#		print("mean :", p_sum.x, p_sum.y) # DEBUG
#		print("max  :", p_max.x, p_max.y) # DEBUG
#		print("----------------------") # DEBUG
#######################################################	
		sv_nb = sv_nb // self.__turns
		center = (p_min + p_max) / 2
		radius = (center.x - p_min.x + center.y - p_min.y) / 2
		p_new = mathutils.Vector([0, 0])
#######################################################
		R = self.__random_radius
		C = self.__random_center
		i = 0
		it = stroke.stroke_vertices_begin()
		for j in range(self.__turns):
			prev_radius = radius
			prev_center = center
			radius = radius + random.randint(-R, R)
			center = center + mathutils.Vector([random.randint(-C, C), random.randint(-C, C)])
			while i < sv_nb and not it.is_end:
				t = float(i) / float(sv_nb - 1)
				r = prev_radius + (radius - prev_radius) * t
				c = prev_center + (center - prev_center) * t
				p_new.x = c.x + r * math.cos(2 * math.pi * t)
				p_new.y = c.y + r * math.sin(2 * math.pi * t)
				it.object.point = p_new
				i = i + 1
				it.increment()
			i = 1
		verticesToRemove = []
		while not it.is_end:
			verticesToRemove.append(it.object)
			it.increment()
		for sv in verticesToRemove:
			stroke.remove_vertex(sv)
		stroke.update_length()

class pyBluePrintEllipsesShader(StrokeShader):
	def __init__(self, turns = 1, random_radius = 3, random_center = 5):
		StrokeShader.__init__(self)
		self.__turns = turns
		self.__random_center = random_center
		self.__random_radius = random_radius
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		if it.is_end:
			return
		p_min = it.object.point.copy()
		p_max = it.object.point.copy()
		while not it.is_end:
			p = it.object.point
			if p.x < p_min.x:
				p_min.x = p.x
			if p.x > p_max.x:
				p_max.x = p.x
			if p.y < p_min.y:
				p_min.y = p.y
			if p.y > p_max.y:
				p_max.y = p.y
			it.increment()
		stroke.resample(32 * self.__turns)
		sv_nb = stroke.stroke_vertices_size()
		sv_nb = sv_nb // self.__turns
		center = (p_min + p_max) / 2
		radius = center - p_min
		p_new = mathutils.Vector([0, 0])
#######################################################
		R = self.__random_radius
		C = self.__random_center
		i = 0
		it = stroke.stroke_vertices_begin()
		for j in range(self.__turns):
			prev_radius = radius
			prev_center = center
			radius = radius + mathutils.Vector([random.randint(-R, R), random.randint(-R, R)])
			center = center + mathutils.Vector([random.randint(-C, C), random.randint(-C, C)])
			while i < sv_nb and not it.is_end:
				t = float(i) / float(sv_nb - 1)
				r = prev_radius + (radius - prev_radius) * t
				c = prev_center + (center - prev_center) * t
				p_new.x = c.x + r.x * math.cos(2 * math.pi * t)
				p_new.y = c.y + r.y * math.sin(2 * math.pi * t)
				it.object.point = p_new
				i = i + 1
				it.increment()
			i = 1
		verticesToRemove = []
		while not it.is_end:
			verticesToRemove.append(it.object)
			it.increment()
		for sv in verticesToRemove:
			stroke.remove_vertex(sv)
		stroke.update_length()


class pyBluePrintSquaresShader(StrokeShader):
	def __init__(self, turns = 1, bb_len = 10, bb_rand = 0):
		StrokeShader.__init__(self)
		self.__turns = turns
		self.__bb_len = bb_len
		self.__bb_rand = bb_rand
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		if it.is_end:
			return
		p_min = it.object.point.copy()
		p_max = it.object.point.copy()
		while not it.is_end:
			p = it.object.point
			if p.x < p_min.x:
				p_min.x = p.x
			if p.x > p_max.x:
				p_max.x = p.x
			if p.y < p_min.y:
				p_min.y = p.y
			if p.y > p_max.y:
				p_max.y = p.y
			it.increment()
		stroke.resample(32 * self.__turns)
		sv_nb = stroke.stroke_vertices_size()
#######################################################	
		sv_nb = sv_nb // self.__turns
		first = sv_nb // 4
		second = 2 * first
		third = 3 * first
		fourth = sv_nb
		p_first = mathutils.Vector([p_min.x - self.__bb_len, p_min.y])
		p_first_end = mathutils.Vector([p_max.x + self.__bb_len, p_min.y])
		p_second = mathutils.Vector([p_max.x, p_min.y - self.__bb_len])
		p_second_end = mathutils.Vector([p_max.x, p_max.y + self.__bb_len])
		p_third = mathutils.Vector([p_max.x + self.__bb_len, p_max.y])
		p_third_end = mathutils.Vector([p_min.x - self.__bb_len, p_max.y])
		p_fourth = mathutils.Vector([p_min.x, p_max.y + self.__bb_len])
		p_fourth_end = mathutils.Vector([p_min.x, p_min.y - self.__bb_len])
#######################################################
		R = self.__bb_rand
		r = self.__bb_rand // 2
		it = stroke.stroke_vertices_begin()
		visible = True
		for j in range(self.__turns):
			p_first = p_first + mathutils.Vector([random.randint(-R, R), random.randint(-r, r)])
			p_first_end = p_first_end + mathutils.Vector([random.randint(-R, R), random.randint(-r, r)])
			p_second = p_second + mathutils.Vector([random.randint(-r, r), random.randint(-R, R)])
			p_second_end = p_second_end + mathutils.Vector([random.randint(-r, r), random.randint(-R, R)])
			p_third = p_third + mathutils.Vector([random.randint(-R, R), random.randint(-r, r)])
			p_third_end = p_third_end + mathutils.Vector([random.randint(-R, R), random.randint(-r, r)])
			p_fourth = p_fourth + mathutils.Vector([random.randint(-r, r), random.randint(-R, R)])
			p_fourth_end = p_fourth_end + mathutils.Vector([random.randint(-r, r), random.randint(-R, R)])
			vec_first = p_first_end - p_first
			vec_second = p_second_end - p_second
			vec_third = p_third_end - p_third
			vec_fourth = p_fourth_end - p_fourth
			i = 0
			while i < sv_nb and not it.is_end:
				if i < first:
					p_new = p_first + vec_first * float(i)/float(first - 1)
					if i == first - 1:
						visible = False
				elif i < second:
					p_new = p_second + vec_second * float(i - first)/float(second - first - 1)
					if i == second - 1:
						visible = False
				elif i < third:
					p_new = p_third + vec_third * float(i - second)/float(third - second - 1)
					if i == third - 1:
						visible = False
				else:
					p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)
					if i == fourth - 1:
						visible = False
				if it.object == None:
					i = i + 1
					it.increment()
					if not visible:
						visible = True
					continue
				it.object.point = p_new
				it.object.attribute.visible = visible
				if not visible:
					visible = True
				i = i + 1
				it.increment()
		verticesToRemove = []
		while not it.is_end:
			verticesToRemove.append(it.object)
			it.increment()
		for sv in verticesToRemove:
			stroke.remove_vertex(sv)
		stroke.update_length()


class pyBluePrintDirectedSquaresShader(StrokeShader):
	def __init__(self, turns = 1, bb_len = 10, mult = 1):
		StrokeShader.__init__(self)
		self.__mult = mult
		self.__turns = turns
		self.__bb_len = 1 + float(bb_len) / 100
	def shade(self, stroke):
		stroke.resample(32 * self.__turns)
		p_mean = mathutils.Vector([0, 0])
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			p = it.object.point
			p_mean = p_mean + p
			it.increment()
		sv_nb = stroke.stroke_vertices_size()
		p_mean = p_mean / sv_nb
		p_var_xx = 0
		p_var_yy = 0
		p_var_xy = 0
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			p = it.object.point
			p_var_xx = p_var_xx + math.pow(p.x - p_mean.x, 2)
			p_var_yy = p_var_yy + math.pow(p.y - p_mean.y, 2)
			p_var_xy = p_var_xy + (p.x - p_mean.x) * (p.y - p_mean.y)
			it.increment()
		p_var_xx = p_var_xx / sv_nb
		p_var_yy = p_var_yy / sv_nb
		p_var_xy = p_var_xy / sv_nb
##		print(p_var_xx, p_var_yy, p_var_xy)
		trace = p_var_xx + p_var_yy
		det = p_var_xx * p_var_yy - p_var_xy * p_var_xy
		sqrt_coeff = math.sqrt(trace * trace - 4 * det)
		lambda1 = (trace + sqrt_coeff) / 2
		lambda2 = (trace - sqrt_coeff) / 2
##		print(lambda1, lambda2)
		theta = math.atan(2 * p_var_xy / (p_var_xx - p_var_yy)) / 2
##		print(theta)
		if p_var_yy > p_var_xx:
			e1 = mathutils.Vector([math.cos(theta + math.pi / 2), math.sin(theta + math.pi / 2)]) * math.sqrt(lambda1) * self.__mult
			e2 = mathutils.Vector([math.cos(theta + math.pi), math.sin(theta + math.pi)]) *  math.sqrt(lambda2) * self.__mult
		else:
			e1 = mathutils.Vector([math.cos(theta), math.sin(theta)]) * math.sqrt(lambda1) * self.__mult
			e2 = mathutils.Vector([math.cos(theta + math.pi / 2), math.sin(theta + math.pi / 2)]) * math.sqrt(lambda2) * self.__mult
#######################################################	
		sv_nb = sv_nb // self.__turns
		first = sv_nb // 4
		second = 2 * first
		third = 3 * first
		fourth = sv_nb
		bb_len1 = self.__bb_len
		bb_len2 = 1 + (bb_len1 - 1) * math.sqrt(lambda1 / lambda2)
		p_first = p_mean - e1 - e2 * bb_len2
		p_second = p_mean - e1 * bb_len1 + e2
		p_third = p_mean + e1 + e2 * bb_len2
		p_fourth = p_mean + e1 * bb_len1 - e2
		vec_first = e2 * bb_len2 * 2
		vec_second = e1 * bb_len1 * 2
		vec_third = vec_first * -1
		vec_fourth = vec_second * -1
#######################################################
		it = stroke.stroke_vertices_begin()
		visible = True
		for j in range(self.__turns):
			i = 0
			while i < sv_nb:
				if i < first:
					p_new = p_first + vec_first * float(i)/float(first - 1)
					if i == first - 1:
						visible = False
				elif i < second:
					p_new = p_second + vec_second * float(i - first)/float(second - first - 1)
					if i == second - 1:
						visible = False
				elif i < third:
					p_new = p_third + vec_third * float(i - second)/float(third - second - 1)
					if i == third - 1:
						visible = False
				else:
					p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)
					if i == fourth - 1:
						visible = False
				it.object.point = p_new
				it.object.attribute.visible = visible
				if not visible:
					visible = True
				i = i + 1
				it.increment()
		verticesToRemove = []
		while not it.is_end:
			verticesToRemove.append(it.object)
			it.increment()
		for sv in verticesToRemove:
			stroke.remove_vertex(sv)
		stroke.update_length()

class pyModulateAlphaShader(StrokeShader):
	def __init__(self, min = 0, max = 1):
		StrokeShader.__init__(self)
		self.__min = min
		self.__max = max
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			alpha = it.object.attribute.alpha
			p = it.object.point
			alpha = alpha * p.y / 400
			if alpha < self.__min:
				alpha = self.__min
			elif alpha > self.__max:
				alpha = self.__max
			it.object.attribute.alpha = alpha
			it.increment()

## various
class pyDummyShader(StrokeShader):
	def shade(self, stroke):
		it = stroke.stroke_vertices_begin()
		while not it.is_end:
			toto = Interface0DIterator(it)
			att = it.object.attribute
			att.color = (0.3, 0.4, 0.4)
			att.thickness = (0, 5)
			it.increment()

class pyDebugShader(StrokeShader):
	def shade(self, stroke):
		fe = CF.get_selected_fedge()
		id1 = fe.first_svertex.id
		id2 = fe.second_svertex.id
		#print(id1.first, id1.second)
		#print(id2.first, id2.second)
		it = stroke.stroke_vertices_begin()
		found = True
		foundfirst = True
		foundsecond = False
		while not it.is_end:
			cp = it.object
			if cp.first_svertex.id == id1 or cp.second_svertex.id == id1:
				foundfirst = True
			if cp.first_svertex.id == id2 or cp.second_svertex.id == id2:
				foundsecond = True
			if foundfirst and foundsecond:
				found = True
				break
			it.increment()
		if found:
			print("The selected Stroke id is: ", stroke.id.first, stroke.id.second)