Differential D319 Diff 1014 release/scripts/freestyle/modules/freestyle/shaders.py

Changeset View

Standalone View

release/scripts/freestyle/modules/freestyle/shaders.py

Context not available.
	from freestyle.predicates import (	from freestyle.predicates import (
	pyVertexNatureUP0D,	pyVertexNatureUP0D,
	)	)
	from freestyle.utils import ContextFunctions as CF	from freestyle.utils import (
		ContextFunctions as CF,
		iter_pair,
		)

	from math import atan, cos, pi, pow, sin, sinh, sqrt	import bpy
	from mathutils import Vector
	from random import randint

		from math import atan, cos, pi, sin, sinh, sqrt
		from random import randint, uniform, seed
		from mathutils import Vector, Color

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

	class pyDepthDiscontinuityThicknessShader(StrokeShader):	"""-- Thickness Stroke Shaders --"""
	"""
	Assigns a thickness to the stroke based on the stroke's distance
	to the camera (Z-value)
	"""
	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.__minz_max-self.__maxz_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()

		kjym3Unsubmitted Not Done Inline Actions Please, consider keeping the original order of classes to make code review easier. kjym3: Please, consider keeping the original order of classes to make code review easier.

	class pyConstantThicknessShader(StrokeShader):	class pyConstantThicknessShader(StrokeShader):
Context not available.
	"""	"""
	def __init__(self, thickness):	def __init__(self, thickness):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._thickness = thickness	self._thickness = thickness / 2.0

	def shade(self, stroke):	def shade(self, stroke):
	it = stroke.stroke_vertices_begin()	for svert in stroke:
	while not it.is_end:	svert.attribute.thickness = (self._thickness, self._thickness)
	t = self._thickness/2.0
	it.object.attribute.thickness = (t, t)	class pyDepthDiscontinuityThicknessShader(StrokeShader):
	it.increment()	"""
		Assigns a thickness to the stroke based on the stroke's distance
		to the camera (Z-value)
		"""
		def __init__(self, min, max):
		StrokeShader.__init__(self)
		self.a = float(max - min)
		self.b = float(min)
		self.__func = ZDiscontinuityF0D()

		def shade(self, stroke):
		it = iter(stroke)
		for svert in it:
		z = self.__func(Interface0DIterator(it))
		thickness = self.a * z + self.b
		svert.attribute.thickness = (thickness, thickness)

	class pyFXSVaryingThicknessWithDensityShader(StrokeShader):	class pyFXSVaryingThicknessWithDensityShader(StrokeShader):
	"""	"""
	Assings thickness to a stroke based on the density of the diffuse map	Assings thickness to a stroke based on the density of the diffuse map

		:arg sigma: The gaussian sigma value indicating the X value for\n
		which the gaussian function is 0.5. It leads to the window size\n
		value (the larger, the smoother)
		:type sigma: float
	"""	"""
	def __init__(self, wsize, threshold_min, threshold_max, thicknessMin, thicknessMax):	def __init__(self, threshold_min, threshold_max, thickness_min, thickness_max, sigma=2):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self.wsize= wsize	self._func = DensityF0D(sigma)
	self.threshold_min= threshold_min	self.threshold_min = threshold_min
	self.threshold_max= threshold_max	self.threshold_max = threshold_max
	self._thicknessMin = thicknessMin	self._thicknessMin = thickness_min
	self._thicknessMax = thicknessMax	self._thicknessMax = thickness_max

	def shade(self, stroke):	def shade(self, stroke):
	n = stroke.stroke_vertices_size()
	i = 0
	it = stroke.stroke_vertices_begin()	it = stroke.stroke_vertices_begin()
	func = DensityF0D(self.wsize)	delta_threshold = self.threshold_max - self.threshold_min
	while not it.is_end:	delta_thickness = self._thicknessMax - self._thicknessMin
	c = func(Interface0DIterator(it))
	if c < self.threshold_min:	for svert in stroke:
	c = self.threshold_min	c = self._func(Interface0DIterator(it))
	if c > self.threshold_max:	# check if c is within the threshold, adjust otherwise
	c = self.threshold_max	c = min(max(c, self.threshold_min), 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) / delta_threshold * delta_thickness + self._thicknessMin
	t = (self.threshold_max - c )/(self.threshold_max - self.threshold_min)*(self._thicknessMax-self._thicknessMin) + self._thicknessMin	svert.attribute.thickness = (t/2.0, t/2.0)
	it.object.attribute.thickness = (t/2.0, t/2.0)
	i = i+1
	it.increment()


	class pyIncreasingThicknessShader(StrokeShader):	class pyIncreasingThicknessShader(StrokeShader):
	"""	"""
	Increasingly thickens the stroke	Increasingly thickens the stroke.

		:arg t_min: The minumum thickness of a stroke vertex.
		:type t_min: float
		:arg t_max: The maximum thickness of a stroke vertex.
		:type t_max: float
	"""	"""
	def __init__(self, thicknessMin, thicknessMax):	def __init__(self, t_min, t_max):
		kjym3Unsubmitted Not Done Inline Actions Casting to float is not necessary in Python 3. An integer divided by another gives a float value. kjym3: Casting to float is not necessary in Python 3. An integer divided by another gives a float…
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._thicknessMin = thicknessMin	self._thicknessMin = t_min
	self._thicknessMax = thicknessMax	self._thicknessMax = t_max

	def shade(self, stroke):	def shade(self, stroke):
	n = stroke.stroke_vertices_size()	n = len(stroke)
	i = 0	for i, svert in enumerate(stroke):
	it = stroke.stroke_vertices_begin()	c = float(i) / n
	while not it.is_end:	if i < (n / 2.0):
	c = float(i)/float(n)	t = (1.0 - c) * self._thicknessMin + c * self._thicknessMax
		kjym3Unsubmitted Not Done Inline Actions c = i / n kjym3: c = i / n
	if i < float(n)/2.0:
	t = (1.0 - c)self._thicknessMin + c self._thicknessMax
	else:	else:
	t = (1.0 - c)self._thicknessMax + c self._thicknessMin	t = (1.0 - c) * self._thicknessMax + c * self._thicknessMin
	it.object.attribute.thickness = (t/2.0, t/2.0)	svert.attribute.thickness = (t/2.0, t/2.0)
	i = i+1
	it.increment()


	class pyConstrainedIncreasingThicknessShader(StrokeShader):	class pyConstrainedIncreasingThicknessShader(StrokeShader):
	"""	"""
	Increasingly thickens the stroke, constrained by a ratio of the	Increasingly thickens the stroke, constrained by a ratio of the
	stroke's length	stroke's length

		:arg t_min: The minumum thickness of a stroke vertex.
		:type t_min: float
		:arg t_max: The maximum thickness of a stroke vertex.
		:type t_max: float
		:arg ratio: ratio of the stroke's length to constrain thickness by.
		:type ratio: float
	"""	"""
	def __init__(self, thicknessMin, thicknessMax, ratio):	def __init__(self, t_min, t_max, ratio):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._thicknessMin = thicknessMin	self._thicknessMin = t_min
	self._thicknessMax = thicknessMax	self._thicknessMax = t_max
	self._ratio = ratio	self._ratio = ratio

	def shade(self, stroke):	def shade(self, stroke):
		kjym3Unsubmitted Not Done Inline Actions c = i / n kjym3: c = i / n
	slength = stroke.length_2d	n = len(stroke)
	tmp = self._ratio*slength	maxT = min((self._ratio * stroke.length_2d), self._thicknessMax)
	maxT = 0.0
	if tmp < self._thicknessMax:	for i, svert in enumerate(stroke):
	maxT = tmp	c = i / n
	else:	if (svert.u < 0.5):
	maxT = self._thicknessMax	t = (1.0 - c) * self._thicknessMin + c * maxT
	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:	else:
	t = (1.0 - c)maxT + c self._thicknessMin	t = (1.0 - c) * maxT + c * self._thicknessMin
	att.thickness = (t/2.0, t/2.0)
	if i == n-1:	if i == (n - 1):
	att.thickness = (self._thicknessMin/2.0, self._thicknessMin/2.0)	att.thickness = (self._thicknessMin/2.0, self._thicknessMin/2.0)
	i = i+1	else:
	it.increment()	att.thickness = (t/2.0, t/2.0)


	class pyDecreasingThicknessShader(StrokeShader):	class pyDecreasingThicknessShader(StrokeShader):
	"""	"""
	Inverse of pyIncreasingThicknessShader, decreasingly thickens the stroke	Inverse of pyIncreasingThicknessShader, decreasingly thickens the stroke.

		kjym3Unsubmitted Not Done Inline Actions Just a thought: This shader relies on vertex index to determine new stroke thickness. That would work fine if the vertex intervals are more and less the same; otherwise nonlinear thickness variation is expected. We might want to rely on the u parameter of the stroke instead, to assure smooth thickness changes. kjym3: Just a thought: This shader relies on vertex index to determine new stroke thickness. That…
		flokkievidsAuthorUnsubmitted Not Done Inline Actions thought about this aswell. speedwise, it should barely matter (may be faster even, albeit mininally) It would however make regression testing inaccurate. I propose to stick to the old approach for now, verify that all works well. Then we can implement the use of the u parameter. flokkievids: thought about this aswell. speedwise, it should barely matter (may be faster even, albeit…
		:arg t_min: The minumum thickness of a stroke vertex.
		:type t_min: float
		:arg t_max: The maximum thickness of a stroke vertex.
		:type t_max: float
	"""	"""
	def __init__(self, thicknessMin, thicknessMax):	def __init__(self, t_min, t_max):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._thicknessMin = thicknessMin	self._thicknessMin = t_min
	self._thicknessMax = thicknessMax	self._thicknessMax = t_max

	def shade(self, stroke):	def shade(self, stroke):
		n = len(stroke)
	l = stroke.length_2d	l = stroke.length_2d
	tMax = self._thicknessMax	tmax = min(self._thicknessMax, 0.33 * l)
	if self._thicknessMax > 0.33*l:	tmin = max(self._thicknessMin, 0.10 * l)
	tMax = 0.33*l
	tMin = self._thicknessMin	for i, svert in enumerate(stroke):
		kjym3Unsubmitted Not Done Inline Actions Redundant casting to float: `c` should already be a float. kjym3: Redundant casting to float: `c` should already be a float.
	if self._thicknessMin > 0.1*l:	c = i / n
	tMin = 0.1*l	t = (1.0 - c) * tMax + c * tMin
	n = stroke.stroke_vertices_size()	svert.attribute.thickness = (t/2.0, t/2.0)
	i = 0
	it = stroke.stroke_vertices_begin()
	while not it.is_end:
	c = float(i)/float(n)
	t = (1.0 - c)tMax +ctMin
	it.object.attribute.thickness = (t/2.0, t/2.0)
	i = i+1
	it.increment()


	class pyNonLinearVaryingThicknessShader(StrokeShader):	class pyNonLinearVaryingThicknessShader(StrokeShader):
	"""	"""
	Assigns thickness to a stroke based on an exponential function	Assigns thickness to a stroke based on an exponential function

		:arg t_min: The minumum thickness of a stroke vertex.
		:type t_min: float
		:arg t_max: The maximum thickness of a stroke vertex.
		:type t_max: float
		:arg exponent: Exponent to use to calculate the thickness
		:type exponent: float
	"""	"""
	def __init__(self, thicknessExtremity, thicknessMiddle, exponent):	def __init__(self, t_min, t_max, exponent):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._thicknessMin = thicknessMiddle	self._thicknessMin = t_min
	self._thicknessMax = thicknessExtremity	self._thicknessMax = t_max
	self._exponent = exponent	self._exp = exponent

	def shade(self, stroke):	def shade(self, stroke):
	n = stroke.stroke_vertices_size()	n = len(stroke)
	i = 0	for i, svert in enumerate(stroke):
	it = stroke.stroke_vertices_begin()	c = i / n if (svert.u < 0.5) else (n - i) / n
	while not it.is_end:	c = (c ** self._exp) * (2.0 ** self._exp)
	if i < float(n)/2.0:	t = (1.0 - c) * self._thicknessMax + c * self._thicknessMin
	c = float(i)/float(n)	svert.attribute.thickness = (t/2.0, t/2.0)
	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 pow(float(a), exp) * pow(2.0, exp)


	class pySLERPThicknessShader(StrokeShader):	class pySLERPThicknessShader(StrokeShader):
	"""	"""
	Assigns thickness to a stroke based on spherical linear interpolation	Assigns thickness to a stroke based on
		spherical linear interpolation (slerp)

		:arg t_min: The minumum thickness of a stroke vertex.
		:type t_min: float
		:arg t_max: The maximum thickness of a stroke vertex.
		:type t_max: float
		:arg omega: Scaling factor
		:type omega: float
	"""	"""
	def __init__(self, thicknessMin, thicknessMax, omega=1.2):	def __init__(self, t_max, t_min, omega=1.2):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._thicknessMin = thicknessMin	self._thicknessMin = t_min
	self._thicknessMax = thicknessMax	self._thicknessMax = t_max
	self._omega = omega	self._omega = omega

	def shade(self, stroke):	def shade(self, stroke):
	slength = stroke.length_2d	n = len(stroke)
	tmp = 0.33*slength	maxT = min(self_thicknessMax, 0.33 * stroke.length_2d)
	maxT = self._thicknessMax	minT = self._thicknessMin
	if tmp < self._thicknessMax:	omega = self._omega
	maxT = tmp	for i, svert in enumerate(stroke):
	n = stroke.stroke_vertices_size()	c = i / n
	i = 0	if svert.u < 0.5:
	it = stroke.stroke_vertices_begin()	t = sin((1-c) * omega) / sinh(omega) * minT + sin(c * omega) / sinh(omega) * maxT
	while not it.is_end:
	c = float(i)/float(n)
	if i < float(n)/2.0:
	t = sin((1-c)self._omega)/sinh(self._omega)self._thicknessMin + sin(cself._omega)/sinh(self._omega) maxT
	else:	else:
	t = sin((1-c)self._omega)/sinh(self._omega)maxT + sin(cself._omega)/sinh(self._omega) self._thicknessMin	t = sin((1-c) * omega) / sinh(omega) * maxT + sin(c * omega) / sinh(omega) * minT
	it.object.attribute.thickness = (t/2.0, t/2.0)	svert.attribute.thickness = (t/2.0, t/2.0)
	i = i+1
	it.increment()


	class pyTVertexThickenerShader(StrokeShader): ## FIXME
	"""
	Thickens TVertices (visual intersections between two edges)
	"""
	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 = (rtr, rtl)
	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 = (rtr, rtl)
	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 = (rtr, rtl)
	it.increment()


	class pyImportance2DThicknessShader(StrokeShader):	class pyImportance2DThicknessShader(StrokeShader):
	"""	"""
	Assigns thickness based on distance to a given point in 2D space.	Assigns thickness based on distance to a given point in 2D space.
	the thickness is inverted, so the vertices closest to the	the thickness is inverted, so the vertices closest to the
	specified point have the lowest thickness	specified point have the lowest thickness
	"""	"""
	def __init__(self, x, y, w, kmin, kmax):	def __init__(self, x, y, w, kmin, kmax):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._x = x	self._origin = Vector((x, y))
	self._y = y
	self._w = float(w)	self._w = float(w)
	self._kmin = float(kmin)	self._kmin = float(kmin)
	self._kmax = float(kmax)	self._kmax = float(kmax)

	def shade(self, stroke):	def shade(self, stroke):
	origin = Vector((self._x, self._y))	for svert in stroke:
	it = stroke.stroke_vertices_begin()	d = (svert.point_2d - self._origin).length
	while not it.is_end:	k = (self._kmin if (d > self.w) else
	v = it.object	(self._kmax * (self._w-d) + self._kmin * d) / self._w)
	d = (v.point_2d - self._origin).length
	if d > self._w:	(tr, tl) = svert.attribute.thickness
	k = self._kmin	svert.attribute.thickness = (ktr/2.0, ktl/2.0)
	else:
	k = (self._kmax(self._w-d) + self._kmind)/self._w
	att = v.attribute
	(tr, tl) = att.thickness
	att.thickness = (ktr/2.0, ktl/2.0)
	it.increment()


	class pyImportance3DThicknessShader(StrokeShader):	class pyImportance3DThicknessShader(StrokeShader):
Context not available.
	"""	"""
	def __init__(self, x, y, z, w, kmin, kmax):	def __init__(self, x, y, z, w, kmin, kmax):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._x = x	self._origin = Vector((x, y, z))
	self._y = y
	self._z = z
	self._w = float(w)	self._w = float(w)
	self._kmin = float(kmin)	self._kmin = float(kmin)
	self._kmax = float(kmax)	self._kmax = float(kmax)

	def shade(self, stroke):	def shade(self, stroke):
	origin = Vector((self._x, self._y, self._z))	for svert in stroke:
	it = stroke.stroke_vertices_begin()	d = (svert.point_3d - self._origin).length
	while not it.is_end:	k = (self._kmin if (d > self.w) else
	v = it.object	(self._kmax * (self._w-d) + self._kmin * d) / self._w)
	p = v.point_3d
	d = (p-origin).length
	if d > self._w:
	k = self._kmin
	else:
	k = (self._kmax(self._w-d) + self._kmind)/self._w
	att = v.attribute
	(tr, tl) = att.thickness
	att.thickness = (ktr/2.0, ktl/2.0)
	it.increment()

		(tr, tl) = svert.attribute.thickness
		svert.attribute.thickness = (ktr/2.0, ktl/2.0)

	class pyZDependingThicknessShader(StrokeShader):	class pyZDependingThicknessShader(StrokeShader):
	"""	"""
	Assigns thickness based on an object's local Z depth (point	Assigns thickness based on an object's local Z depth (point
	closest to camera is 1, point furthest from camera is zero)	closest to camera is 1, point furthest from camera is zero)

		:arg min: distance to camera below which
		depth values won't be taken into account.
		:type min: float
		:arg max: distance to camera above which
		depth values won't be taken into account.
		:type min: float
	"""	"""
	def __init__(self, min, max):	def __init__(self, min, max):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self.__min = min	self.__min = min
	self.__max = max	self.__max = max
		self.__z_diff = 1 / (z_max - z_min)
	self.__func = GetProjectedZF0D()	self.__func = GetProjectedZF0D()

		kjym3Unsubmitted Not Done Inline Actions Now this can be `it = Interface0DIterator(stroke)`. kjym3: Now this can be `it = Interface0DIterator(stroke)`.
	def shade(self, stroke):	def shade(self, stroke):
	it = stroke.stroke_vertices_begin()	it = Interface0DIterator(stroke)
	z_min = 1
	z_max = 0	z_indices = tuple(self.__func(it) for obj in it)
	while not it.is_end:	z_min, z_max = min(z_indices), max(z_indices)
	z = self.__func(Interface0DIterator(it))
	if z < z_min:
	z_min = z	for svert, z_index in zip(stroke, z_indices):
	if z > z_max:	z = (z_index - z_min) * self.z_diff
	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	thickness = (1 - z) * self.__max + z * self.__min
	it.object.attribute.thickness = (thickness, thickness)	svert.attribute.thickness = (thickness, thickness)
	it.increment()

		class pyTVertexThickenerShader(StrokeShader):
		"""
		Thickens TVertices (visual intersections between two edges)

		:arg a: Scale factor
		:type a: float
		:arg n: Ammount of vertices to thicken (behind the tvertex)
		:type n: float
		"""
		def __init__(self, a=1.5, n=3):
		StrokeShader.__init__(self)
		self._a = a
		self._n = n

		def shade(self, stroke):
		it = iter(stroke)
		n = self._n
		a = self._a

		if len(stroke) < n:
		return None

		for strokevertex in it:
		if (strokevertex.nature & Nature.T_VERTEX):
		it2 = StrokeVertexIterator(it)
		it2.increment()

		if not (it.is_begin or it2.is_end):
		continue

		if it.is_begin:
		it3 = StrokeVertexIterator(it)
		for count, svert in zip(range(n), it3):
		r = ((a - 1.0) / (n - 1.0) * (n / (count + 1.0) - 1.0) + 1.0)
		(tr, tl) = svert.attribute.thickness
		svert.attribute.thickness = (rtr, rtl)

		elif it2.is_end:
		it4 = StrokeVertexIterator(it, reversed=True)
		for count, svert in zip(range(n), it4):
		# use different expression for r, since the iterator
		# is reversed.
		r = ((a - 1.0) / (n - 1.0) * (count / n - 1.0) + 1.0)
		(tr, tl) = svert.attribute.thickness
		svert.attribute.thickness = (rtr, rtl)

		if it4.is_begin:
		r = ((a - 1.0) / (n - 1.0) * (count / n - 1.0) + 1.0)
		(tr, tl) = it4.object.attribute.thickness
		it4.object.attribute.thickness = (rtr, rtl)

		kjym3Unsubmitted Not Done Inline Actions c = 1.0 - 2.0 * abs(i / n - 0.5) kjym3: c = 1.0 - 2.0 * abs(i / n - 0.5)
	## color modifiers
	##################	"""-- Color & Alpha Stroke Shaders --"""

	class pyConstantColorShader(StrokeShader):	class pyConstantColorShader(StrokeShader):
	"""	"""
	Assigns a constant color to the stroke	Assigns a constant color to the stroke
	"""	"""
	def __init__(self, r, g, b, a=1):	def __init__(self,r,g,b, a=1):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._r = r	self._color = (r, g, b)
	self._g = g
	self._b = b
	self._a = a	self._a = a

	def shade(self, stroke):	def shade(self, stroke):
	it = stroke.stroke_vertices_begin()	for svert in stroke:
	while not it.is_end:	svert.attribute.color = self._color
	att = it.object.attribute	svert.attribute.alpha = self._a
	att.color = (self._r, self._g, self._b)
	att.alpha = self._a
	it.increment()


	class pyIncreasingColorShader(StrokeShader):	class pyIncreasingColorShader(StrokeShader):
Context not available.
	"""	"""
	def __init__(self,r1,g1,b1,a1, r2,g2,b2,a2):	def __init__(self,r1,g1,b1,a1, r2,g2,b2,a2):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._c1 = [r1,g1,b1,a1]	# use 4d vector to simplify math
	self._c2 = [r2,g2,b2,a2]	self._c1 = Vector((r1,g1,b1,a1))
		self._c2 = Vector((r2,g2,b2,a2))

	def shade(self, stroke):	def shade(self, stroke):
	n = stroke.stroke_vertices_size() - 1	n = len(stroke) - 1
	inc = 0
	it = stroke.stroke_vertices_begin()	for svert in stroke:
	while not it.is_end:	c = float(inc)/float(n)
	att = it.object.attribute	color = (1 - c) * self._c1 + c * self._c2
	c = float(inc) / float(n)	svert.attribute.color = color[3:]
		svert.attribute.alpha = color[3]

		kjym3Unsubmitted Not Done Inline Actions it = Interface0DIterator(stroke) for svert in it: mat = self._func(it) kjym3: it = Interface0DIterator(stroke) for svert in it: mat = self._func(it)
	att.color = ((1.0 - c) * self._c1[0] + c * self._c2[0],
	(1.0 - c) * self._c1[1] + c * self._c2[1],
	(1.0 - c) * self._c1[2] + c * self._c2[2])
	att.alpha = (1.0 - c) * self._c1[3] + c * self._c2[3]
	inc = inc + 1
	it.increment()


	class pyInterpolateColorShader(StrokeShader):	class pyInterpolateColorShader(StrokeShader):
Context not available.
	"""	"""
	def __init__(self,r1,g1,b1,a1, r2,g2,b2,a2):	def __init__(self,r1,g1,b1,a1, r2,g2,b2,a2):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._c1 = [r1,g1,b1,a1]	# use 4d vector to simplify math
	self._c2 = [r2,g2,b2,a2]	self._c1 = Vector((r1,g1,b1,a1))
		self._c2 = Vector((r2,g2,b2,a2))

	def shade(self, stroke):	def shade(self, stroke):
	n = stroke.stroke_vertices_size() - 1	n = len(stroke) - 1
	inc = 0	for i, svert in enumerate(stroke):
	it = stroke.stroke_vertices_begin()	c = 1 - 2 * abs((float(i)/float(n)) - 0.5)
	while not it.is_end:	svert.attribute.color = color[3:]
	att = it.object.attribute	svert.attribute.alpha = color[3]
	u = float(inc) / float(n)
	c = 1.0 - 2.0 * abs(u - 0.5)	class pyModulateAlphaShader(StrokeShader):
	att.color = ((1.0 - c) * self._c1[0] + c * self._c2[0],	"""
	(1.0 - c) * self._c1[1] + c * self._c2[1],	Limits the stroke's alpha between a min and max value.
	(1.0 - c) * self._c1[2] + c * self._c2[2])
	att.alpha = (1.0-c) * self._c1[3] + c * self._c2[3]
	inc = inc+1
	it.increment()

		:arg min: The minimum value for alpha.
		:type min: float
		:arg max: The maximum value for alpha.
		:type min: float
		"""
		def __init__(self, min=0, max=1):
		StrokeShader.__init__(self)
		self.__min = min
		self.__max = max
		def shade(self, stroke):
		for svert in stroke:
		alpha = svert.attribute.alpha
		alpha = svert.point.y 0.04
		alpha = min(max(self.__min, alpha), self.__max)
		svert.attribute.alpha = alpha

	class pyMaterialColorShader(StrokeShader):	class pyMaterialColorShader(StrokeShader):
	"""	"""
	Assigns the color of the underlying material to the stroke	Assigns the color of the underlying material to the stroke

		:arg threshold: Used for smoother colors.
		:type threshold: float
	"""	"""
	def __init__(self, threshold=50):	def __init__(self, threshold=50):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._threshold = threshold	self._threshold = threshold
		self._func = MaterialF0D()

	def shade(self, stroke):	def shade(self, stroke):
	it = stroke.stroke_vertices_begin()
	func = MaterialF0D()
	xn = 0.312713	xn = 0.312713
	yn = 0.329016	yn = 0.329016
	Yn = 1.0	Yn = 1.0
	un = 4.* xn / (-2.xn + 12.yn + 3.)	un = 4.* xn / (-2.xn + 12.yn + 3.)
	vn= 9.* yn / (-2.xn + 12.yn +3.)	vn= 9.* yn / (-2.xn + 12.yn +3.)
	while not it.is_end:	it = iter(stroke)
	mat = func(Interface0DIterator(it))	for svert in it:
		mat = self._func(Interface0DIterator(it))

	r = mat.diffuse[0]	r, g, b, *rest = mat.diffuse
	g = mat.diffuse[1]
	b = mat.diffuse[2]

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

	if (X, Y, Z) == (0, 0, 0):	if (X, Y, Z) == (0, 0, 0):
	X = 0.01	X = Y = Z = 0.1
		kjym3Unsubmitted Not Done Inline Actions it = Interface0DIterator(stroke) for svert in it: c = func(it) kjym3: it = Interface0DIterator(stroke) for svert in it: c = func(it)
	Y = 0.01
	Z = 0.01
	u = 4.X / (X + 15.Y + 3.*Z)
	v = 9.Y / (X + 15.Y + 3.*Z)

	L= 116. * pow((Y/Yn),(1./3.)) -16	u = 4.X / (X + 15. Y + 3.*Z)
		v = 9.Y / (X + 15. Y + 3.*Z)
		kjym3Unsubmitted Not Done Inline Actions The constant is 0.01 in the original code. kjym3: The constant is 0.01 in the original code.

		L= 116. * pow((Y/Yn),(1. / 3.)) - 16
	U = 13. * L * (u - un)	U = 13. * L * (u - un)
	V = 13. * L * (v - vn)	V = 13. * L * (v - vn)

	if L > self._threshold:	if L > self._threshold:
	L = L/1.3	L /= 1.3
	U = U+10	U += 10.
	else:	else:
	L = L +2.5*(100-L)/5.	L = L + 2.5 * (100-L) * 0.2
	U = U/3.0	U /= 3.0
	V = V/3.0	V /= 3.0
	u = U / (13. * L) + un
	v = V / (13. * L) + vn	u = U / (13.0 * L) + un
		v = V / (13.0 * L) + vn

	Y = Yn * pow(((L+16.)/116.), 3.)	Y = Yn * pow(((L + 16.) / 116.), 3.)
	X = -9.0 * Y * u / ((u - 4.0) * v - u * v)	X = -9.0 * Y * u / ((u - 4.)* v - u * v)
	Z = (9.0 * Y - 15.0 * v * Y - v * X) / (3.0 * v)	Z = (9.0 * Y - 15.0 * v * Y - v * X) /( 3.0 * v)

	r = 3.240479 * X - 1.53715 * Y - 0.498535 * Z	r = 3.240479 * X - 1.53715 * Y - 0.498535 * Z
	g = -0.969256 * X + 1.875991 * Y + 0.041556 * Z	g = -0.969256 * X + 1.875991 * Y + 0.041556 * Z
	b = 0.055648 * X - 0.204043 * Y + 1.057311 * Z	b = 0.055648 * X - 0.204043 * Y + 1.057311 * Z

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

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


	class pyRandomColorShader(StrokeShader):	class pyRandomColorShader(StrokeShader):
	"""	"""
	Assigns a color to the stroke based on given seed	Assigns a color to the stroke based on given seed

		:arg seed: Seed for the random number generator.
		:type seed: int
	"""	"""
	def __init__(self, s=1):	def __init__(self, seed=1):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	random.seed(s)	seed(s)

	def shade(self, stroke):	def shade(self, stroke):
	## pick a random color	## pick a random color
	c0 = float(random.uniform(15,75))/100.0	c0 = uniform(15, 75) * 0.01
	c1 = float(random.uniform(15,75))/100.0	c1 = uniform(15, 75) * 0.01
	c2 = float(random.uniform(15,75))/100.0	c2 = uniform(15, 75) * 0.01
	#print(c0, c1, c2)
	it = stroke.stroke_vertices_begin()
	while not it.is_end:
	it.object.attribute.color = (c0,c1,c2)
	it.increment()

		for svert in stroke:
		svert.attribute.color = (c0, c1, c2)

	class py2DCurvatureColorShader(StrokeShader):	class py2DCurvatureColorShader(StrokeShader):
	"""	"""Shader assigning color based on curvature
	Assigns a color (greyscale) to the stroke based on the curvature.
	A higher curvature will yield a brighter color	:arg c1: First color
	"""	:type c1: sequence
		:arg c2: Second color
		:type c2: sequence
		:arg fac: Optional factor to make color differences more visible
		:type fac: float
		"""
		def __init__(self, c1=(0, 0, 0), c2=(1, 1, 1), fac=2):
		self.color1 = Color(c1)
		self.color2 = Color(c2)
		self.func = Curvature2DAngleF0D()
		self.fac = fac * 3.14159
		StrokeShader.__init__(self)

	def shade(self, stroke):	def shade(self, stroke):
	it = stroke.stroke_vertices_begin()	it = iter(stroke)
	func = Curvature2DAngleF0D()
	while not it.is_end:	for i, svert in enumerate(it):
	c = func(Interface0DIterator(it))	c = self.func(Interface0DIterator(it)) * self.fac
	if c < 0:	if c < 0 and bpy.app.debug_freestyle:
	print("negative 2D curvature")	print("py2DCurvatureColorShader: negative 2D curvature")
	color = 10.0 * c/3.1415	svert.attribute.color = (1.0 - c) * self.color1 + c * self.color2
	it.object.attribute.color = (color, color, color)
	it.increment()	# Old version of this shader, kept for future reference
		# class py2DCurvatureColorShader(StrokeShader):
		# """
		# Assigns a color (greyscale) to the stroke based on the curvature.
		# A higher curvature will yield a brighter color
		# """
		# def shade(self, stroke):
		# func = Curvature2DAngleF0D()
		# it = iter(stroke)
		# for svert in it:
		# c = func(Interface0DIterator(it))

		# color = 10.0 * c / 3.1415
		# svert.attribute.color = (color, color, color)


	class pyTimeColorShader(StrokeShader):	class pyTimeColorShader(StrokeShader):
	"""	"""
	Assigns a greyscale value that increases for every vertex.	Assigns a greyscale value that increases for every vertex.
	The brightness will increase along the stroke	The brightness will increase along the stroke

		:arg step: Ammount to increase the color by on each iteration.
		:type step: float
	"""	"""
	def __init__(self, step=0.01):	def __init__(self, step=0.01):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._step = step	self._step = step

	def shade(self, stroke):	def shade(self, stroke):
		kjym3Unsubmitted Not Done Inline Actions How about using the notation `stroke[0]`, `stroke[-1]` and so on here? That makes the creation of iterators unnecessary. kjym3: How about using the notation `stroke[0]`, `stroke[-1]` and so on here? That makes the creation…
	for i, svert in enumerate(iter(stroke)):	for i, svert in enumerate(stroke):
	c = i * self._step	c = i * self._step
	svert.attribute.color = (c,c,c)	svert.attribute.color = (c,c,c)

	## geometry modifiers

		"""-- Geometry Stroke Shaders --"""

	class pySamplingShader(StrokeShader):	class pySamplingShader(StrokeShader):
	"""	"""
Context not available.
	def __init__(self, sampling):	def __init__(self, sampling):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._sampling = sampling	self._sampling = sampling

	def shade(self, stroke):	def shade(self, stroke):
	stroke.resample(float(self._sampling))	stroke.resample(float(self._sampling))
	stroke.update_length()	stroke.update_length()


	class pyBackboneStretcherShader(StrokeShader):	class pyBackboneStretcherShader(StrokeShader):
	"""	"""
	Stretches the stroke's backbone by a given length (in pixels)	Stretches the stroke's backbone by a given length (in pixels)
Context not available.
	def __init__(self, l):	def __init__(self, l):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._l = l	self._l = l

	def shade(self, stroke):	def shade(self, stroke):
	it0 = stroke.stroke_vertices_begin()	# get first two vertices
	it1 = StrokeVertexIterator(it0)	it = iter(stroke)
	it1.increment()	first = (next(it), next(it))
	itn = stroke.stroke_vertices_end()	# get final two vertices
	itn.decrement()	it = stroke.stroke_vertices_end()
	itn_1 = StrokeVertexIterator(itn)	final = (next(it), next(it))
	itn_1.decrement()	# calculate new points and assign them
	v0 = it0.object	d1 = (first[0].point_2d - first[1].point_2d).normalized()
	v1 = it1.object	dn = (final[0].point_2d - final[1].point_2d).normalized()
	vn_1 = itn_1.object	first[0].point += d1 * self._l
	vn = itn.object	final[0].point += dn * self._l
	p0 = v0.point_2d
	pn = vn.point_2d
	p1 = v1.point_2d
	pn_1 = vn_1.point_2d
	d1 = (p0 - p1).normalized()
	dn = (pn - pn_1).normalized()
	newFirst = p0+d1*float(self._l)
	newLast = pn+dn*float(self._l)
	v0.point = newFirst
	vn.point = newLast
	stroke.update_length()	stroke.update_length()


	class pyLengthDependingBackboneStretcherShader(StrokeShader):	class pyLengthDependingBackboneStretcherShader(StrokeShader):
	"""	"""
	Stretches the stroke's backbone proportional to the stroke's length	Stretches the stroke's backbone proportional to the stroke's length
Context not available.
	def __init__(self, l):	def __init__(self, l):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._l = l	self._l = l
		kjym3Unsubmitted Not Done Inline Actions These nested for loops are difficult to read... Why not iterate self._nbIter-1 times and creating a new Interface0DIterator instance inside the loop? for i in range(1, self._nbIter): it = Interface0DIterator(stroke) for svert in it: # this works in Python svert.point += self._normal(it) * self._lambda * self._angle(it) kjym3: These nested for loops are difficult to read... Why not iterate self._nbIter-1 times and…
		kjym3Unsubmitted Not Done Inline Actions Please, consider revising these nested for loops as suggested in https://developer.blender.org/D319?id=1881#inline-1886. kjym3: Please, consider revising these nested for loops as suggested in https://developer.blender.

	def shade(self, stroke):	def shade(self, stroke):
	l = stroke.length_2d	stretch = self._l * stroke.length_2d
	stretch = self._l*l	# get first two vertices
	it0 = stroke.stroke_vertices_begin()	it = iter(stroke)
	it1 = StrokeVertexIterator(it0)	first = (next(it), next(it))
	it1.increment()	# get final two vertices
	itn = stroke.stroke_vertices_end()	it = stroke.stroke_vertices_end()
	itn.decrement()	final = (next(it), next(it))
	itn_1 = StrokeVertexIterator(itn)	# calculate new points and assign them
	itn_1.decrement()	d1 = (first[0].point_2d - first[1].point_2d).normalized()
	v0 = it0.object	dn = (final[0].point_2d - final[1].point_2d).normalized()
	v1 = it1.object	first[0].point += d1 * stretch
	vn_1 = itn_1.object	final[0].point += dn * stretch
	vn = itn.object
	p0 = v0.point_2d
	pn = vn.point_2d
	p1 = v1.point_2d
	pn_1 = vn_1.point_2d
	d1 = (p0 - p1).normalized()
	dn = (pn - pn_1).normalized()
	newFirst = p0+d1*float(stretch)
	newLast = pn+dn*float(stretch)
	v0.point = newFirst
	vn.point = newLast
	stroke.update_length()	stroke.update_length()


		## reversed attribute would be handy to set here

	class pyGuidingLineShader(StrokeShader):	class pyGuidingLineShader(StrokeShader):
	"""	"""
	Replaces the stroke by its corresponding tangent	Replaces the stroke by its corresponding tangent
	"""	"""
	def shade(self, stroke):	def shade(self, stroke):
	it = stroke.stroke_vertices_begin() ## get the first vertex	# get the distance between the first and final vertex
	itlast = stroke.stroke_vertices_end() ##	it = iter(stroke)
	itlast.decrement() ## get the last one	itlast = stroke.stroke_vertices_end()
	t = itlast.object.point - it.object.point ## tangent direction	t = itlast.object.point - it.object.point
	itmiddle = StrokeVertexIterator(it) ##	# search for the middle vertex
	while itmiddle.object.u < 0.5: ## look for the stroke middle vertex	itmiddle = iter(stroke)
	itmiddle.increment() ##	while itmiddle.object.u < 0.5:
		it.increment()
		center_point = itmiddle.object.point

	it = StrokeVertexIterator(itmiddle)	it = StrokeVertexIterator(itmiddle)
	it.increment()	it.increment()
	while not it.is_end: ## position all the vertices along the tangent for the right part	## position all the vertices along the tangent for the right part
	it.object.point = itmiddle.object.point+t*(it.object.u-itmiddle.object.u)	for svert in it:
	it.increment()	svert.point = itmiddle.object.point + t * (it.object.u - itmiddle.object.u)
	it = StrokeVertexIterator(itmiddle)	## position all the vertices along the tangent for the left part
	it.decrement()	for svert in stroke.stroke_vertices_end():
	while not it.is_begin: ## position all the vertices along the tangent for the left part	svert.point = itmiddle.object.point - t * (itmiddle.object.u - it.object.u)
	it.object.point = itmiddle.object.point-t*(itmiddle.object.u-it.object.u)	if svert.u > 0.5:
	it.decrement()	break
	it.object.point = itmiddle.object.point-t*itmiddle.object.u ## first vertex
	stroke.update_length()	stroke.update_length()


Context not available.
	self._l = l	self._l = l

	def shade(self, stroke):	def shade(self, stroke):
	it0 = stroke.stroke_vertices_begin()	# get first two vertices
	it1 = StrokeVertexIterator(it0)	it = iter(stroke)
	it1.increment()	v0, v1 = (next(it), next(it))
	itn = stroke.stroke_vertices_end()	# get final two vertices
	itn.decrement()	it = stroke.stroke_vertices_end()
	itn_1 = StrokeVertexIterator(itn)	vn, vn_1 = (next(it), next(it))
	itn_1.decrement()
		kjym3Unsubmitted Not Done Inline Actions Using Iterface1D.vertices_begin() may further simplify the updated code (not tested): it = stroke.vertices_begin() for svert in it: svert.point += self._normal(it) * self._lambda * self._angle(it) It is noted that the .object property of Interface0DIterator gives a StrokeVertex instance if the iterator is created from Stroke. Python does not have a `dynamic_cast` operator available in C++, so casting to StrokeVertex is automatically done when the .object property value is returned. kjym3: Using Iterface1D.vertices_begin() may further simplify the updated code (not tested): it =…
	v0 = it0.object	if not (v0.nature & Nature.CUSP) and not (v1.nature & Nature.CUSP):
	v1 = it1.object
	if (v0.nature & Nature.CUSP) == 0 and (v1.nature & Nature.CUSP) == 0:
	d1 = (v0.point - v1.point).normalized()	d1 = (v0.point - v1.point).normalized()
	newFirst = p0+d1*float(self._l)	v0.point += d1 * self._l
	v0.point = newFirst
		kjym3Unsubmitted Not Done Inline Actions it2 = it.incremented() kjym3: it2 = it.incremented()
	vn_1 = itn_1.object	if not (vn.nature & Nature.CUSP) and not (vn_1.nature & Nature.CUSP):
	vn = itn.object
	if (vn.nature & Nature.CUSP) == 0 and (vn_1.nature & Nature.CUSP) == 0:
	dn = (vn.point - vn_1.point).normalized()	dn = (vn.point - vn_1.point).normalized()
	newLast = vn.point + dn * float(self._l)	vn.point += dn * self._l
	vn.point = newLast
	stroke.update_length()	stroke.update_length()


	class pyDiffusion2Shader(StrokeShader):	class pyDiffusion2Shader(StrokeShader):
	"""	"""
	Iteratively adds an offset to the position of each stroke vertex	Iteratively adds an offset to the position of each stroke vertex
		kjym3Unsubmitted Not Done Inline Actions No return value is required. kjym3: No return value is required.
		flokkievidsAuthorUnsubmitted Not Done Inline Actions in python, explicit is said to be better than implicit. I like this better than the empty 'return'. it is explicit about what it returns. flokkievids: in python, explicit is said to be better than implicit. I like this better than the empty…
		kjym3Unsubmitted Not Done Inline Actions I agree that explicit is better than implicit in Python. In this case, however, the `shade()` method is not supposed to return a value. Explicitly returning None appears weird to me. kjym3: I agree that explicit is better than implicit in Python. In this case, however, the `shade()`…
Context not available.
	self._curvatureInfo = Curvature2DAngleF0D()	self._curvatureInfo = Curvature2DAngleF0D()

	def shade(self, stroke):	def shade(self, stroke):
	for i in range (1, self._nbIter):	it = Interface0DIterator(stroke)
	it = stroke.stroke_vertices_begin()	points = (self._normal(it) * self._lambda * self._angle(it) for _ in it)
		kjym3Unsubmitted Not Done Inline Actions it = Interface0DIterator(stroke) for svert in it: normal = self._getNormal(it) kjym3: it = Interface0DIterator(stroke) for svert in it: normal = self._getNormal(it)
	while not it.is_end:	for i in range (1, self._nbIter):
	v = it.object	for svert, point in zip(stroke, points):
	p1 = v.point	svert.point += point
	p2 = self._normalInfo(Interface0DIterator(it))self._lambdaself._curvatureInfo(Interface0DIterator(it))
	v.point = p1+p2
	it.increment()
	stroke.update_length()	stroke.update_length()


	class pyTipRemoverShader(StrokeShader):	class pyTipRemoverShader(StrokeShader):
	"""	"""
	Removes the tips of the stroke	Removes the tips of the stroke
Context not available.
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self._l = l	self._l = l

		def check_vertex(self, vert):
		return (vert.curvilinear_abscissa < self._l or
		v.stroke_length - vert.curvilinear_abscissa < self._l)

	def shade(self, stroke):	def shade(self, stroke):
	originalSize = stroke.stroke_vertices_size()	n = len(stroke)
	if originalSize < 4:	# at least four vertices are needed to remove tips
	return	if (n < 4):
	verticesToRemove = []	return None
		kjym3Unsubmitted Not Done Inline Actions Using `stroke[0]` and `stroke[-1]` would be easier. kjym3: Using `stroke[0]` and `stroke[-1]` would be easier.
	oldAttributes = []
	it = stroke.stroke_vertices_begin()	verticesToRemove = tuple(svert for svert in stroke if check_vertex(svert))
	while not it.is_end:	oldAttributes = (svert.attribute for svert in verticesToRemove)
	v = it.object
	if v.curvilinear_abscissa < self._l or v.stroke_length-v.curvilinear_abscissa < self._l:	if (n - len(verticesToRemove)) < 2:
	verticesToRemove.append(v)	return None
	oldAttributes.append(StrokeAttribute(v.attribute))
	it.increment()
	if originalSize-len(verticesToRemove) < 2:
	return
	for sv in verticesToRemove:	for sv in verticesToRemove:
	stroke.remove_vertex(sv)	stroke.remove_vertex(sv)

	stroke.update_length()	stroke.update_length()
	stroke.resample(originalSize)	stroke.resample(n)
	if stroke.stroke_vertices_size() != originalSize:	if len(stroke) != n and bpy.app.debug_freestyle:
	print("pyTipRemover: Warning: resampling problem")	print("pyTipRemover: Warning: resampling problem")
	it = stroke.stroke_vertices_begin()	it = stroke.stroke_vertices_begin()
	for a in oldAttributes:	for a, svert in zip(oldAttributes, stroke):
	if it.is_end:	svert.attribute = a
	break
	it.object.attribute = a
	it.increment()
	stroke.update_length()	stroke.update_length()


	class pyTVertexRemoverShader(StrokeShader):	class pyTVertexRemoverShader(StrokeShader):
	"""	"""
	Removes t-vertices from the stroke	Removes t-vertices from the stroke
		kjym3Unsubmitted Not Done Inline Actions An explicit int comparison `qi == 0` is preferable to me. kjym3: An explicit int comparison `qi == 0` is preferable to me.
	"""	"""
	def shade(self, stroke):	def shade(self, stroke):
	if stroke.stroke_vertices_size() <= 3:	if len(stroke) < 4:
	return	return None
	predTVertex = pyVertexNatureUP0D(Nature.T_VERTEX)	v0 = next(stroke.stroke_vertices_begin())
	it = stroke.stroke_vertices_begin()	vn = next(stroke.stroke_vertices_end())
	itlast = stroke.stroke_vertices_end()	if (v0.nature & Nature.T_VERTEX):
	itlast.decrement()	stroke.remove_vertex(v0)
	if predTVertex(it):	if (vn.nature & Nature.T_VERTEX):
	stroke.remove_vertex(it.object)	stroke.remove_vertex(vn.object)
	if predTVertex(itlast):
	stroke.remove_vertex(itlast.object)
	stroke.update_length()	stroke.update_length()

		# deprecated, kept for possible future use
	#class pyExtremitiesOrientationShader(StrokeShader):	#class pyExtremitiesOrientationShader(StrokeShader):
	# def __init__(self, x1,y1,x2=0,y2=0):	# def __init__(self, x1,y1,x2=0,y2=0):
	# StrokeShader.__init__(self)	# StrokeShader.__init__(self)
Context not available.
	# stroke.setBeginningOrientation(self._v1.x,self._v1.y)	# stroke.setBeginningOrientation(self._v1.x,self._v1.y)
	# stroke.setEndingOrientation(self._v2.x,self._v2.y)	# stroke.setEndingOrientation(self._v2.x,self._v2.y)


	class pyHLRShader(StrokeShader):	class pyHLRShader(StrokeShader):
	"""	"""
	Controlls visibility based upon the quantative invisibility (QI)	Controlls visibility based upon the quantative invisibility (QI)
	based on hidden line removal (HLR)	based on hidden line removal (HLR).
	"""	"""
	def shade(self, stroke):	def shade(self, stroke):
	originalSize = stroke.stroke_vertices_size()	if len(stroke) < 4:
	if originalSize < 4:	return None
	return
	it = stroke.stroke_vertices_begin()	it = stroke.stroke_vertices_begin()
	invisible = 0	v1, v2 = (next(it), next(it))
	it2 = StrokeVertexIterator(it)
	it2.increment()	fe = v1.get_fedge(v2)
	fe = self.get_fedge(it.object, it2.object)	visible = not bool(fe.viewedge.qi)
	if fe.viewedge.qi != 0:	for v1, v2 in iter_pair(stroke):
	invisible = 1	if (v1.nature & Nature.VIEW_VERTEX):
	while not it2.is_end:	fe = v0.get_fedge(v1)
	v = it.object	invisible = bool(fe.viewedge.qi)
	vnext = it2.object	v0.attribute.visible = visible
	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)


	# broken and a mess	# broken and a mess
Context not available.
	self._Get2dDirection = Orientation2DF1D()	self._Get2dDirection = Orientation2DF1D()
		kjym3Unsubmitted Not Done Inline Actions I believe `verticesToRemove = tuple(svert for svert in it)` is safer (see https://developer.blender.org/D319?id=1502#inline-1884 ). kjym3: I believe `verticesToRemove = tuple(svert for svert in it)` is safer (see https://developer.
		flokkievidsAuthorUnsubmitted Not Done Inline Actions I hadn't noticed yet. a change of test scene revealed this problem. fixed it now flokkievids: I hadn't noticed yet. a change of test scene revealed this problem. fixed it now
	## finds the TVertex orientation from the TVertex and	## finds the TVertex orientation from the TVertex and
	## the previous or next edge	## the previous or next edge

	def findOrientation(self, tv, ve):	def findOrientation(self, tv, ve):
	mateVE = tv.get_mate(ve)	mateVE = tv.get_mate(ve)
	if ve.qi != 0 or mateVE.qi != 0:	if ve.qi != 0 or mateVE.qi != 0:
Context not available.
	direction = self._Get2dDirection(winner.first_fedge)	direction = self._Get2dDirection(winner.first_fedge)
	return direction	return direction
	return None	return None

	def castToTVertex(self, cp):	def castToTVertex(self, cp):
	if cp.t2d() == 0.0:	if cp.t2d() == 0.0:
	return cp.first_svertex.viewvertex	return cp.first_svertex.viewvertex
Context not available.
	def get_fedge(self, it1, it2):	def get_fedge(self, it1, it2):
	return it1.get_fedge(it2)	return it1.get_fedge(it2)


	class pySinusDisplacementShader(StrokeShader):	class pySinusDisplacementShader(StrokeShader):
	"""	"""
	Displaces the stroke in the shape of a sine wave	Displaces the stroke in the shape of a sine wave
Context not available.
	self._getNormal = Normal2DF0D()	self._getNormal = Normal2DF0D()

	def shade(self, stroke):	def shade(self, stroke):
	it = stroke.stroke_vertices_begin()	it = iter(stroke)
	while not it.is_end:	for svert in it:
	v = it.object	normal = self._getNormal(Interface0DIterator(it))
	#print(self._getNormal.name)	a = self._a * (1 - 2 * (abs(svert.u - 0.5)))
	n = self._getNormal(Interface0DIterator(it))	n = normal * a * cos(self._f * svert.u * 6.28)
	p = v.point
	u = v.u
	a = self._a(1-2(abs(u-0.5)))
	n = nacos(self._fu6.28)
	#print(n.x, n.y)
	v.point = p+n
	#v.point = v.point+nacos(f*v.u)	#v.point = v.point+nacos(f*v.u)
	it.increment()	svert.point += n
	stroke.update_length()	stroke.update_length()


	class pyPerlinNoise1DShader(StrokeShader):	class pyPerlinNoise1DShader(StrokeShader):
	"""	"""
	Displaces the stroke using the curvilinear abscissa. This means	Displaces the stroke using the curvilinear abscissa. This means
Context not available.
	self.__oct = oct	self.__oct = oct

	def shade(self, stroke):	def shade(self, stroke):
	it = stroke.stroke_vertices_begin()	for svert in stroke:
	while not it.is_end:	i = svert.projected_x + svert.projected_y
	v = it.object
	i = v.projected_x + v.projected_y
	nres = self.__noise.turbulence1(i, self.__freq, self.__amp, self.__oct)	nres = self.__noise.turbulence1(i, self.__freq, self.__amp, self.__oct)
	v.point = (v.projected_x + nres, v.projected_y + nres)	svert.point = (svert.projected_x + nres, svert.projected_y + nres)
	it.increment()
	stroke.update_length()	stroke.update_length()
		kjym3Unsubmitted Not Done Inline Actions A shorter form `tuple(it)` could be used here instead of `(svert for svert in it)`, but maybe the former appears too cryptic. I prefer the latter. kjym3: A shorter form `tuple(it)` could be used here instead of `(svert for svert in it)`, but maybe…
		flokkievidsAuthorUnsubmitted Not Done Inline Actions actually, verticesToRemove is a generator object here. altough the effect in this case may be minimal, I think it is a good practice to use generators when possible. flokkievids: actually, verticesToRemove is a generator object here. altough the effect in this case may be…
		kjym3Unsubmitted Not Done Inline Actions I agree with you that using generators when possible is a good practice. Another concern I got is whether using a generator here is safe or not. The generator `(svert for svert in it)` keeps a pointer to a StrokeVertex in a sequence of objects, and does not keep all references of the StrokeVertex objects to be removed. This situation is similar to a common coding error in Python where items are removed from a list within a loop over the list item: for x in somelist: somelist.remove(x) Since Python programmers are familiar with this common mistake, it would appear straightforward that `verticesToRemove` is a genuine list or tuple. kjym3: I agree with you that using generators when possible is a good practice. Another concern I got…


	class pyPerlinNoise2DShader(StrokeShader):	class pyPerlinNoise2DShader(StrokeShader):
	"""	"""
		kjym3Unsubmitted Not Done Inline Actions This assignment seems redundant. kjym3: This assignment seems redundant.
	Displaces the stroke using the strokes coordinates. This means	Displaces the stroke using the strokes coordinates. This means
Context not available.
	self.__oct = oct	self.__oct = oct

	def shade(self, stroke):	def shade(self, stroke):
	it = stroke.stroke_vertices_begin()	for svert in stroke:
	while not it.is_end:	nres = self.__noise.turbulence2(svert.point_2d, self.__freq, self.__amp, self.__oct)
	v = it.object	svert.point = (svert.projected_x + nres, svert.projected_y + nres)
	nres = self.__noise.turbulence2(v.point_2d, self.__freq, self.__amp, self.__oct)
	v.point = (v.projected_x + nres, v.projected_y + nres)
	it.increment()
	stroke.update_length()	stroke.update_length()


	class pyBluePrintCirclesShader(StrokeShader):	class pyBluePrintCirclesShader(StrokeShader):
	"""	"""
	Draws the silhouette of the object as a circle	Draws the silhouette of the object as a circle
	"""	"""
	def __init__(self, turns=1, random_radius=3, random_center=5):	def __init__(self, turns=1, random_radius=15, random_center=5):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
		kjym3Unsubmitted Not Done Inline Actions I guess `p_mean = (1 / n) * sum(svert.point for svert in stroke)` would suffice? kjym3: I guess `p_mean = (1 / n) * sum(svert.point for svert in stroke)` would suffice?
		flokkievidsAuthorUnsubmitted Not Done Inline Actions It doesn't, sadly. it raises: AttributeError: Vector addition: (int + Vector) invalid type for this operation including the empty Vector as a starting point makes this work. flokkievids: It doesn't, sadly. it raises: AttributeError: Vector addition: (int + Vector) invalid type for…
		kjym3Unsubmitted Not Done Inline Actions Ok, sum() takes two arguments and the second is the initial value, which in this case should be Vector((0, 0)). No problem then. kjym3: Ok, sum() takes two arguments and the second is the initial value, which in this case should be…
	self.__turns = turns	self.__turns = turns
	self.__random_center = random_center	self.__random_center = random_center
	self.__random_radius = random_radius	self.__random_radius = random_radius

	def shade(self, stroke):	def shade(self, stroke):
	it = stroke.stroke_vertices_begin()	p_min, p_max = stroke[0].point.copy(), stroke[0].point.copy()
	if it.is_end:	for svert in stroke:
		kjym3Unsubmitted Not Done Inline Actions Please, remove this debug print. kjym3: Please, remove this debug print.
	return	p = svert.point
	p_min = it.object.point.copy()	p_min.x = min(p_min.x, p.x)
	p_max = it.object.point.copy()	p_max.x = max(p_max.x, p.x)
	while not it.is_end:	p_min.y = min(p_min.y, p.y)
	p = it.object.point	p_max.y = max(p_max.y, p.y)
	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)	stroke.resample(32 * self.__turns)
	sv_nb = stroke.stroke_vertices_size()	num_segments = len(stroke) // self.__turns
	# 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	center = (p_min + p_max) / 2
	radius = (center.x - p_min.x + center.y - p_min.y) / 2	radius = (center.x - p_min.x + center.y - p_min.y) / 2
	p_new = Vector((0.0, 0.0))	p_new = Vector((0,0))
	#######################################################
	R = self.__random_radius	R = self.__random_radius
	C = self.__random_center	C = self.__random_center
	i = 0
	it = stroke.stroke_vertices_begin()	it = iter(stroke)
	for j in range(self.__turns):	for j in range(self.__turns):
	prev_radius = radius	prev_radius = radius
	prev_center = center	prev_center = center
	radius = radius + randint(-R, R)	radius += randint(-R, R)
	center = center + Vector((randint(-C, C), randint(-C, C)))	center += Vector((randint(-C, C), randint(-C, C)))
	while i < sv_nb and not it.is_end:	for i, svert in zip(range(num_segments), it):
	t = float(i) / float(sv_nb - 1)	t = float(i) / float(num_segments - 1)
	r = prev_radius + (radius - prev_radius) * t	r = prev_radius + (radius - prev_radius) * t
	c = prev_center + (center - prev_center) * t	c = prev_center + (center - prev_center) * t
	p_new.x = c.x + r * cos(2 * pi * t)	svert.point = c + r * Vector((cos(6.28 * t), sin(6.28 * t)))
	p_new.y = c.y + r * sin(2 * pi * t)
	it.object.point = p_new	verticesToRemove = tuple(svert for svert in it)
	i = i + 1
	it.increment()
	i = 1
	verticesToRemove = []
	while not it.is_end:
	verticesToRemove.append(it.object)
	it.increment()
	for sv in verticesToRemove:	for sv in verticesToRemove:
	stroke.remove_vertex(sv)	stroke.remove_vertex(sv)
	stroke.update_length()	stroke.update_length()


	class pyBluePrintEllipsesShader(StrokeShader):	class pyBluePrintEllipsesShader(StrokeShader):
	"""
	Draws the silhouette of the object as an ellips
	"""
	def __init__(self, turns=1, random_radius=3, random_center=5):	def __init__(self, turns=1, random_radius=3, random_center=5):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self.__turns = turns	self.__turns = turns
Context not available.
	self.__random_radius = random_radius	self.__random_radius = random_radius

	def shade(self, stroke):	def shade(self, stroke):
	it = stroke.stroke_vertices_begin()	p_min, p_max = stroke[0].point.copy(), stroke[0].point.copy()
	if it.is_end:	for svert in stroke:
	return	p = svert.point
	p_min = it.object.point.copy()	p_min.x = min(p_min.x, p.x)
	p_max = it.object.point.copy()	p_max.x = max(p_max.x, p.x)
	while not it.is_end:	p_min.y = min(p_min.y, p.y)
	p = it.object.point	p_max.y = max(p_max.y, p.y)
	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)	stroke.resample(32 * self.__turns)
	sv_nb = stroke.stroke_vertices_size()	num_segments = len(stroke) // self.__turns
	sv_nb = sv_nb // self.__turns	center = (p_min + p_max) * 0.5
	center = (p_min + p_max) / 2
	radius = center - p_min	radius = center - p_min
	p_new = Vector((0.0, 0.0))	R, C = self.__random_radius, self.__random_center
	#######################################################
	R = self.__random_radius	it = iter(stroke)
	C = self.__random_center
	i = 0
	it = stroke.stroke_vertices_begin()
	for j in range(self.__turns):	for j in range(self.__turns):
	prev_radius = radius	prev_radius, prev_center = radius, center
	prev_center = center	radius += Vector((randint(-R, R), randint(-R, R)))
	radius = radius + Vector((randint(-R, R), randint(-R, R)))	center += Vector((randint(-C, C), randint(-C, C)))
	center = center + Vector((randint(-C, C), randint(-C, C)))	for i, svert in zip(range(num_segments), it):
	while i < sv_nb and not it.is_end:	t = i / (num_segments - 1)
	t = float(i) / float(sv_nb - 1)
	r = prev_radius + (radius - prev_radius) * t	r = prev_radius + (radius - prev_radius) * t
	c = prev_center + (center - prev_center) * t	c = prev_center + (center - prev_center) * t
	p_new.x = c.x + r.x * cos(2 * pi * t)	svert.point = Vector((c.x + r.x * cos(6.28 * t),
	p_new.y = c.y + r.y * sin(2 * pi * t)	c.y + r.y * sin(6.28 * t)))
	it.object.point = p_new
	i = i + 1	# remove excess vertices
	it.increment()	verticesToRemove = (svert for svert in it)
	i = 1
	verticesToRemove = []
	while not it.is_end:
	verticesToRemove.append(it.object)
	it.increment()
	for sv in verticesToRemove:	for sv in verticesToRemove:
	stroke.remove_vertex(sv)	stroke.remove_vertex(sv)
	stroke.update_length()	stroke.update_length()


	class pyBluePrintSquaresShader(StrokeShader):	class pyBluePrintSquaresShader(StrokeShader):
	"""
	Draws the silhouette of the object as a square
	"""
	def __init__(self, turns=1, bb_len=10, bb_rand=0):	def __init__(self, turns=1, bb_len=10, bb_rand=0):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self.__turns = turns	self.__turns = turns # does not have any effect atm
	self.__bb_len = bb_len	self.__bb_len = bb_len
	self.__bb_rand = bb_rand	self.__bb_rand = bb_rand

	def shade(self, stroke):	def shade(self, stroke):
	it = stroke.stroke_vertices_begin()	# copy the point; it may change in this proces
	if it.is_end:	p_min, p_max = stroke[0].point.copy(), stroke[0].point.copy()
	return	# aquire the minimum and maximum values of the points
	p_min = it.object.point.copy()	for svert in stroke:
	p_max = it.object.point.copy()	p = svert.point
	while not it.is_end:	p_min.x = min(p_min.x, p.x)
	p = it.object.point	p_max.x = max(p_max.x, p.x)
	if p.x < p_min.x:	p_min.y = min(p_min.y, p.y)
	p_min.x = p.x	p_max.y = max(p_max.y, p.y)
	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)	stroke.resample(32 * self.__turns)
	sv_nb = stroke.stroke_vertices_size()	num_segments = len(stroke) // self.__turns
	#######################################################	f = num_segments // 4
	sv_nb = sv_nb // self.__turns	# prevent division by zero later
	first = sv_nb // 4	f = 1.0 + 1e-6 if (f == 1.0) else f
	second = 2 * first	# indices of the vertices that will form corners
	third = 3 * first	first, second, third, fourth = (f, f * 2, f * 3, f * 4)
	fourth = sv_nb
	p_first = Vector((p_min.x - self.__bb_len, p_min.y))
	p_first_end = Vector((p_max.x + self.__bb_len, p_min.y))
	p_second = Vector((p_max.x, p_min.y - self.__bb_len))
	p_second_end = Vector((p_max.x, p_max.y + self.__bb_len))	# construct points of the backbone
	p_third = Vector((p_max.x + self.__bb_len, p_max.y))	bb_len = self.__bb_len
	p_third_end = Vector((p_min.x - self.__bb_len, p_max.y))	points = (
	p_fourth = Vector((p_min.x, p_max.y + self.__bb_len))	(p_min.x - bb_len, p_min.y),
	p_fourth_end = Vector((p_min.x, p_min.y - self.__bb_len))	(p_max.x + bb_len, p_min.y),
	#######################################################	(p_max.x, p_min.y - bb_len),
	R = self.__bb_rand	(p_max.x, p_max.y + bb_len),
	r = self.__bb_rand // 2	(p_max.x + bb_len, p_max.y),
	it = stroke.stroke_vertices_begin()	(p_min.x - bb_len, p_max.y),
	visible = True	(p_min.x, p_max.y + bb_len),
	for j in range(self.__turns):	(p_min.x, p_min.y - bb_len),
	p_first = p_first + Vector((randint(-R, R), randint(-r, r)))	)
	p_first_end = p_first_end + Vector((randint(-R, R), randint(-r, r)))
	p_second = p_second + Vector((randint(-r, r), randint(-R, R)))	# add randomization to the points (if needed)
	p_second_end = p_second_end + Vector((randint(-r, r), randint(-R, R)))	if self.__bb_rand:
	p_third = p_third + Vector((randint(-R, R), randint(-r, r)))	R, r = self.__bb_rand, self.__bb_rand // 2
	p_third_end = p_third_end + Vector((randint(-R, R), randint(-r, r)))
	p_fourth = p_fourth + Vector((randint(-r, r), randint(-R, R)))	randomization_mat = (
	p_fourth_end = p_fourth_end + Vector((randint(-r, r), randint(-R, R)))	(randint(-R, R), randint(-r, r)),
	vec_first = p_first_end - p_first	(randint(-R, R), randint(-r, r)),
	vec_second = p_second_end - p_second	(randint(-r, r), randint(-R, R)),
	vec_third = p_third_end - p_third	(randint(-r, r), randint(-R, R)),
	vec_fourth = p_fourth_end - p_fourth	(randint(-R, R), randint(-r, r)),
	i = 0	(randint(-R, R), randint(-r, r)),
	while i < sv_nb and not it.is_end:	(randint(-r, r), randint(-R, R)),
		(randint(-r, r), randint(-R, R)),
		)

		# combine both tuples (convert to Vector on the fly)
		comb = zip(points, randomization_mat)
		points = tuple(Vector(p) + Vector(rand) for p, rand in comb)
		else:
		points = tuple(Vector(p) for p in points)


		old_vecs = tuple(points[i + 1] - points[i] for i in range(0, 7, 2))




		verticesToRemove = list()
		for j in range(self.__turns):
		it = iter(stroke)
		for i, svert in zip(range(num_segments), it):
	if i < first:	if i < first:
	p_new = p_first + vec_first * float(i)/float(first - 1)	svert.point = points[0] + old_vecs[0] * i / (first - 1)
	if i == first - 1:	svert.attribute.visible = (i != first - 1)
	visible = False
	elif i < second:	elif i < second:
	p_new = p_second + vec_second * float(i - first)/float(second - first - 1)	svert.point = points[2] + old_vecs[1] * (i - first) / (second - first - 1)
	if i == second - 1:	svert.attribute.visible = (i != second - 1)
	visible = False
	elif i < third:	elif i < third:
	p_new = p_third + vec_third * float(i - second)/float(third - second - 1)	svert.point = points[4] + old_vecs[2] * (i - second) / (third - second - 1)
	if i == third - 1:	svert.attribute.visible = (i != third - 1)
	visible = False	elif i < fourth:
		svert.point = points[6] + old_vecs[3] * (i - third) / (fourth - third - 1)
		svert.attribute.visible = (i != fourth - 1)
	else:	else:
	p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)	# special case; remove these vertices
	if i == fourth - 1:	verticesToRemove.append(svert)
	visible = False	pass
	if it.object is None:
	i = i + 1
	it.increment()	# remove exessive vertices
	if not visible:	if not it.is_end:
	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()	it.increment()
	for sv in verticesToRemove:	verticesToRemove += [svert for svert in it]
	stroke.remove_vertex(sv)	for sv in verticesToRemove:
		stroke.remove_vertex(sv)
	stroke.update_length()	stroke.update_length()


	# needs a docstring	# is still a bit buggy
	class pyBluePrintDirectedSquaresShader(StrokeShader):	class pyBluePrintDirectedSquaresShader(StrokeShader):
		"""
		Replaces the stroke with a directed square
		"""
	def __init__(self, turns=1, bb_len=10, mult=1):	def __init__(self, turns=1, bb_len=10, mult=1):
	StrokeShader.__init__(self)	StrokeShader.__init__(self)
	self.__mult = mult	self.__mult = mult
	self.__turns = turns	self.__turns = turns
	self.__bb_len = 1 + float(bb_len) / 100	self.__bb_len = 1 + float(bb_len) * 0.01

	def shade(self, stroke):	def shade(self, stroke):
	stroke.resample(32 * self.__turns)	stroke.resample(32 * self.__turns)

	p_mean = Vector((0.0, 0.0))	p_mean = Vector((0.0, 0.0))
	it = stroke.stroke_vertices_begin()	for svert in stroke:
	while not it.is_end:	p_mean += svert.point
	p = it.object.point	p_mean /= len(stroke)
	p_mean = p_mean + p
	it.increment()	p_var = Vector((0.0, 0.0))
	sv_nb = stroke.stroke_vertices_size()	p_var_xy = 0.0
	p_mean = p_mean / sv_nb	for svert in stroke:
	p_var_xx = 0	d = svert.point - p_mean
	p_var_yy = 0	p_var += Vector((d.x 2, d.y 2))
	p_var_xy = 0	p_var_xy += d.x * d.y
	it = stroke.stroke_vertices_begin()
	while not it.is_end:	# divide by number of vertices
	p = it.object.point	p_var.x /= len(stroke)
	p_var_xx = p_var_xx + pow(p.x - p_mean.x, 2)	p_var.y /= len(stroke)
	p_var_yy = p_var_yy + pow(p.y - p_mean.y, 2)	p_var_xy /= len(stroke)
	p_var_xy = p_var_xy + (p.x - p_mean.x) * (p.y - p_mean.y)	trace = p_var.x + v_var.y
	it.increment()	det = p_var.x * p_var.y - pow(p_var_xy, 2)
	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 = sqrt(trace * trace - 4 * det)	sqrt_coeff = sqrt(trace * trace - 4 * det)
	lambda1 = (trace + sqrt_coeff) / 2	lambda1, lambda2 = (trace + sqrt_coeff) / 2, (trace - sqrt_coeff) / 2
	lambda2 = (trace - sqrt_coeff) / 2	# make sure those numers aren't to small, rooting them will yield complex numbers
	## print(lambda1, lambda2)	lambda1, lambda2 = max(1e-12, lambda1), max(1e-12, lambda2)
	theta = atan(2 * p_var_xy / (p_var_xx - p_var_yy)) / 2	theta = atan(2 * p_var_xy / (p_var.x - p_var.y)) / 2
	## print(theta)
	if p_var_yy > p_var_xx:
	e1 = Vector((cos(theta + pi / 2), sin(theta + pi / 2))) * sqrt(lambda1) * self.__mult	if p_var.y > p_var.x:
	e2 = Vector((cos(theta + pi), sin(theta + pi))) * sqrt(lambda2) * self.__mult	# note: 1.57... = pi / 2
		e1 = Vector((cos(theta + 1.5708), sin(theta + 1.5708))) * sqrt(lambda1) * self.__mult
		e2 = Vector((cos(theta + 3.1416), sin(theta + 3.1416))) * sqrt(lambda2) * self.__mult
	else:	else:
	e1 = Vector((cos(theta), sin(theta))) * sqrt(lambda1) * self.__mult	e1 = Vector((cos(theta), sin(theta))) * sqrt(lambda1) * self.__mult
	e2 = Vector((cos(theta + pi / 2), sin(theta + pi / 2))) * sqrt(lambda2) * self.__mult	e2 = Vector((cos(theta + 1.5708), sin(theta + 1.5708))) * sqrt(lambda2) * self.__mult
	#######################################################
	sv_nb = sv_nb // self.__turns	print(e1, e2, p_var.y > p_var.x)
	first = sv_nb // 4	# partition the stroke
	second = 2 * first	num_segments = len(stroke) // self.__turns
	third = 3 * first	f = num_segments // 4
	fourth = sv_nb	# indices of the vertices that will form corners
		first, second, third, fourth = (f, f * 2, f * 3, f * 4)

	bb_len1 = self.__bb_len	bb_len1 = self.__bb_len
	bb_len2 = 1 + (bb_len1 - 1) * sqrt(lambda1 / lambda2)	bb_len2 = 1 + (bb_len1 - 1) * sqrt(lambda1 / lambda2)
	p_first = p_mean - e1 - e2 * bb_len2	points = (
	p_second = p_mean - e1 * bb_len1 + e2	p_mean - e1 - e2 * bb_len2,
	p_third = p_mean + e1 + e2 * bb_len2	p_mean - e1 * bb_len1 + e2,
	p_fourth = p_mean + e1 * bb_len1 - e2	p_mean + e1 + e2 * bb_len2,
	vec_first = e2 * bb_len2 * 2	p_mean + e1 * bb_len1 - e2,
	vec_second = e1 * bb_len1 * 2	)
	vec_third = vec_first * -1
	vec_fourth = vec_second * -1	old_vecs = (
	#######################################################	e2 * bb_len2 * 2,
	it = stroke.stroke_vertices_begin()	e1 * bb_len1 * 2,
	visible = True	-e2 * bb_len2 * 2,
	for j in range(self.__turns):	-e1 * bb_len1 * 2,
	i = 0	)
	while i < sv_nb:
		it = iter(stroke)
		verticesToRemove = list()
		for j in range(self.__turns):
		for i, svert in zip(range(num_segments), it):
	if i < first:	if i < first:
	p_new = p_first + vec_first * float(i)/float(first - 1)	svert.point = points[0] + old_vecs[0] * i / (first - 1)
	if i == first - 1:	svert.attribute.visible = (i != first - 1)
	visible = False
	elif i < second:	elif i < second:
	p_new = p_second + vec_second * float(i - first)/float(second - first - 1)	svert.point = points[1] + old_vecs[1] * (i - first) / (second - first - 1)
	if i == second - 1:	svert.attribute.visible = (i != second - 1)
	visible = False
	elif i < third:	elif i < third:
	p_new = p_third + vec_third * float(i - second)/float(third - second - 1)	svert.point = points[2] + old_vecs[2] * (i - second) / (third - second - 1)
	if i == third - 1:	svert.attribute.visible = (i != third - 1)
	visible = False	elif i < fourth:
		svert.point = points[3] + old_vecs[3] * (i - third) / (fourth - third - 1)
		svert.attribute.visible = (i != fourth - 1)
	else:	else:
	p_new = p_fourth + vec_fourth * float(i - third)/float(fourth - third - 1)	# special case; remove these vertices
	if i == fourth - 1:	verticesToRemove.append(svert)
	visible = False
	it.object.point = p_new	# remove exessive vertices
	it.object.attribute.visible = visible	if not it.is_end:
	if not visible:
	visible = True
	i = i + 1
	it.increment()
	verticesToRemove = []
	while not it.is_end:
	verticesToRemove.append(it.object)
	it.increment()	it.increment()
	for sv in verticesToRemove:	verticesToRemove += [svert for svert in it]
	stroke.remove_vertex(sv)	for sv in verticesToRemove:
		stroke.remove_vertex(sv)
	stroke.update_length()	stroke.update_length()


		kjym3Unsubmitted Not Done Inline Actions Is this `strokeAsBezierShader` class meant to be here? kjym3: Is this `strokeAsBezierShader` class meant to be here?
		flokkievidsAuthorUnsubmitted Not Done Inline Actions No. this was an experiment with your similar shader. we can look into inclusion of such a shader after this patch gets applied. flokkievids: No. this was an experiment with your similar shader. we can look into inclusion of such a…
	class pyModulateAlphaShader(StrokeShader):
	"""
	Limits the stroke's alpha between a min and max value
	"""
	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	## various
Context not available.
	att.thickness = (0, 5)	att.thickness = (0, 5)
	it.increment()	it.increment()


	class pyDebugShader(StrokeShader):	class pyDebugShader(StrokeShader):
	def shade(self, stroke):	def shade(self, stroke):
	fe = CF.get_selected_fedge()	fe = CF.get_selected_fedge()
Context not available.
		kjym3Unsubmitted Not Done Inline Actions These 3 lines look like testing stuff. Please, remove them if they are unnecessary for a release. kjym3: These 3 lines look like testing stuff. Please, remove them if they are unnecessary for a…