# ##### 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 : parameter_editor.py # Authors : Tamito Kajiyama # Date : 26/07/2010 # Purpose : Interactive manipulation of stylization parameters from freestyle.types import ( BinaryPredicate1D, IntegrationType, Interface0DIterator, Nature, Noise, Operators, StrokeAttribute, UnaryPredicate0D, UnaryPredicate1D, TVertex, ) from freestyle.chainingiterators import ( ChainPredicateIterator, ChainSilhouetteIterator, pySketchyChainSilhouetteIterator, pySketchyChainingIterator, ) from freestyle.functions import ( Curvature2DAngleF0D, CurveMaterialF0D, Normal2DF0D, QuantitativeInvisibilityF1D, VertexOrientation2DF0D, ) from freestyle.predicates import ( AndUP1D, ContourUP1D, ExternalContourUP1D, FalseBP1D, FalseUP1D, Length2DBP1D, NotBP1D, NotUP1D, OrUP1D, QuantitativeInvisibilityUP1D, TrueBP1D, TrueUP1D, WithinImageBoundaryUP1D, pyNatureUP1D, pyZBP1D, ) from freestyle.shaders import ( BackboneStretcherShader, BezierCurveShader, BlenderTextureShader, ConstantColorShader, GuidingLinesShader, PolygonalizationShader, SamplingShader, SpatialNoiseShader, StrokeShader, StrokeTextureStepShader, TipRemoverShader, pyBluePrintCirclesShader, pyBluePrintEllipsesShader, pyBluePrintSquaresShader, ) from freestyle.utils import ( ContextFunctions, getCurrentScene, stroke_normal, ) from _freestyle import ( blendRamp, evaluateColorRamp, evaluateCurveMappingF, ) import math import mathutils import time class ColorRampModifier(StrokeShader): def __init__(self, blend, influence, ramp): StrokeShader.__init__(self) self.__blend = blend self.__influence = influence self.__ramp = ramp def evaluate(self, t): col = evaluateColorRamp(self.__ramp, t) col = col.xyz # omit alpha return col def blend_ramp(self, a, b): return blendRamp(self.__blend, a, self.__influence, b) class ScalarBlendModifier(StrokeShader): def __init__(self, blend, influence): StrokeShader.__init__(self) self.__blend = blend self.__influence = influence def blend(self, v1, v2): fac = self.__influence facm = 1.0 - fac if self.__blend == 'MIX': v1 = facm * v1 + fac * v2 elif self.__blend == 'ADD': v1 += fac * v2 elif self.__blend == 'MULTIPLY': v1 *= facm + fac * v2 elif self.__blend == 'SUBTRACT': v1 -= fac * v2 elif self.__blend == 'DIVIDE': if v2 != 0.0: v1 = facm * v1 + fac * v1 / v2 elif self.__blend == 'DIFFERENCE': v1 = facm * v1 + fac * abs(v1 - v2) elif self.__blend == 'MININUM': tmp = fac * v2 if v1 > tmp: v1 = tmp elif self.__blend == 'MAXIMUM': tmp = fac * v2 if v1 < tmp: v1 = tmp else: raise ValueError("unknown curve blend type: " + self.__blend) return v1 class CurveMappingModifier(ScalarBlendModifier): def __init__(self, blend, influence, mapping, invert, curve): ScalarBlendModifier.__init__(self, blend, influence) assert mapping in {'LINEAR', 'CURVE'} self.__mapping = getattr(self, mapping) self.__invert = invert self.__curve = curve def LINEAR(self, t): if self.__invert: return 1.0 - t return t def CURVE(self, t): return evaluateCurveMappingF(self.__curve, 0, t) def evaluate(self, t): return self.__mapping(t) class ThicknessModifierMixIn: def __init__(self): scene = getCurrentScene() self.__persp_camera = (scene.camera.data.type == 'PERSP') def set_thickness(self, sv, outer, inner): fe = sv.first_svertex.get_fedge(sv.second_svertex) nature = fe.nature if (nature & Nature.BORDER): if self.__persp_camera: point = -sv.point_3d.copy() point.normalize() dir = point.dot(fe.normal_left) else: dir = fe.normal_left.z if dir < 0.0: # the back side is visible outer, inner = inner, outer elif (nature & Nature.SILHOUETTE): if fe.is_smooth: # TODO more tests needed outer, inner = inner, outer else: outer = inner = (outer + inner) / 2 sv.attribute.thickness = (outer, inner) class ThicknessBlenderMixIn(ThicknessModifierMixIn): def __init__(self, position, ratio): ThicknessModifierMixIn.__init__(self) self.__position = position self.__ratio = ratio def blend_thickness(self, outer, inner, v): v = self.blend(outer + inner, v) if self.__position == 'CENTER': outer = v * 0.5 inner = v - outer elif self.__position == 'INSIDE': outer = 0 inner = v elif self.__position == 'OUTSIDE': outer = v inner = 0 elif self.__position == 'RELATIVE': outer = v * self.__ratio inner = v - outer else: raise ValueError("unknown thickness position: " + self.__position) return outer, inner class BaseColorShader(ConstantColorShader): pass class BaseThicknessShader(StrokeShader, ThicknessModifierMixIn): def __init__(self, thickness, position, ratio): StrokeShader.__init__(self) ThicknessModifierMixIn.__init__(self) if position == 'CENTER': self.__outer = thickness * 0.5 self.__inner = thickness - self.__outer elif position == 'INSIDE': self.__outer = 0 self.__inner = thickness elif position == 'OUTSIDE': self.__outer = thickness self.__inner = 0 elif position == 'RELATIVE': self.__outer = thickness * ratio self.__inner = thickness - self.__outer else: raise ValueError("unknown thickness position: " + self.position) def shade(self, stroke): it = stroke.stroke_vertices_begin() while not it.is_end: sv = it.object self.set_thickness(sv, self.__outer, self.__inner) it.increment() # Along Stroke modifiers def iter_t2d_along_stroke(stroke): total = stroke.length_2d distance = 0.0 it = stroke.stroke_vertices_begin() prev = it.object.point while not it.is_end: p = it.object.point distance += (prev - p).length prev = p.copy() # need a copy because the point can be altered t = min(distance / total, 1.0) if total > 0.0 else 0.0 yield it, t it.increment() class ColorAlongStrokeShader(ColorRampModifier): def shade(self, stroke): for it, t in iter_t2d_along_stroke(stroke): sv = it.object a = sv.attribute.color b = self.evaluate(t) sv.attribute.color = self.blend_ramp(a, b) class AlphaAlongStrokeShader(CurveMappingModifier): def shade(self, stroke): for it, t in iter_t2d_along_stroke(stroke): sv = it.object a = sv.attribute.alpha b = self.evaluate(t) sv.attribute.alpha = self.blend(a, b) class ThicknessAlongStrokeShader(ThicknessBlenderMixIn, CurveMappingModifier): def __init__(self, thickness_position, thickness_ratio, blend, influence, mapping, invert, curve, value_min, value_max): ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio) CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.__value_min = value_min self.__value_max = value_max def shade(self, stroke): for it, t in iter_t2d_along_stroke(stroke): sv = it.object a = sv.attribute.thickness b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min) c = self.blend_thickness(a[0], a[1], b) self.set_thickness(sv, c[0], c[1]) # Distance from Camera modifiers def iter_distance_from_camera(stroke, range_min, range_max): normfac = range_max - range_min # normalization factor it = stroke.stroke_vertices_begin() while not it.is_end: p = it.object.point_3d # in the camera coordinate distance = p.length if distance < range_min: t = 0.0 elif distance > range_max: t = 1.0 else: t = (distance - range_min) / normfac yield it, t it.increment() class ColorDistanceFromCameraShader(ColorRampModifier): def __init__(self, blend, influence, ramp, range_min, range_max): ColorRampModifier.__init__(self, blend, influence, ramp) self.__range_min = range_min self.__range_max = range_max def shade(self, stroke): for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max): sv = it.object a = sv.attribute.color b = self.evaluate(t) sv.attribute.color = self.blend_ramp(a, b) class AlphaDistanceFromCameraShader(CurveMappingModifier): def __init__(self, blend, influence, mapping, invert, curve, range_min, range_max): CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.__range_min = range_min self.__range_max = range_max def shade(self, stroke): for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max): sv = it.object a = sv.attribute.alpha b = self.evaluate(t) sv.attribute.alpha = self.blend(a, b) class ThicknessDistanceFromCameraShader(ThicknessBlenderMixIn, CurveMappingModifier): def __init__(self, thickness_position, thickness_ratio, blend, influence, mapping, invert, curve, range_min, range_max, value_min, value_max): ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio) CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.__range_min = range_min self.__range_max = range_max self.__value_min = value_min self.__value_max = value_max def shade(self, stroke): for it, t in iter_distance_from_camera(stroke, self.__range_min, self.__range_max): sv = it.object a = sv.attribute.thickness b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min) c = self.blend_thickness(a[0], a[1], b) self.set_thickness(sv, c[0], c[1]) # Distance from Object modifiers def iter_distance_from_object(stroke, object, range_min, range_max): scene = getCurrentScene() mv = scene.camera.matrix_world.copy() # model-view matrix mv.invert() loc = mv * object.location # loc in the camera coordinate normfac = range_max - range_min # normalization factor it = stroke.stroke_vertices_begin() while not it.is_end: p = it.object.point_3d # in the camera coordinate distance = (p - loc).length if distance < range_min: t = 0.0 elif distance > range_max: t = 1.0 else: t = (distance - range_min) / normfac yield it, t it.increment() class ColorDistanceFromObjectShader(ColorRampModifier): def __init__(self, blend, influence, ramp, target, range_min, range_max): ColorRampModifier.__init__(self, blend, influence, ramp) self.__target = target self.__range_min = range_min self.__range_max = range_max def shade(self, stroke): if self.__target is None: return for it, t in iter_distance_from_object(stroke, self.__target, self.__range_min, self.__range_max): sv = it.object a = sv.attribute.color b = self.evaluate(t) sv.attribute.color = self.blend_ramp(a, b) class AlphaDistanceFromObjectShader(CurveMappingModifier): def __init__(self, blend, influence, mapping, invert, curve, target, range_min, range_max): CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.__target = target self.__range_min = range_min self.__range_max = range_max def shade(self, stroke): if self.__target is None: return for it, t in iter_distance_from_object(stroke, self.__target, self.__range_min, self.__range_max): sv = it.object a = sv.attribute.alpha b = self.evaluate(t) sv.attribute.alpha = self.blend(a, b) class ThicknessDistanceFromObjectShader(ThicknessBlenderMixIn, CurveMappingModifier): def __init__(self, thickness_position, thickness_ratio, blend, influence, mapping, invert, curve, target, range_min, range_max, value_min, value_max): ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio) CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.__target = target self.__range_min = range_min self.__range_max = range_max self.__value_min = value_min self.__value_max = value_max def shade(self, stroke): if self.__target is None: return for it, t in iter_distance_from_object(stroke, self.__target, self.__range_min, self.__range_max): sv = it.object a = sv.attribute.thickness b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min) c = self.blend_thickness(a[0], a[1], b) self.set_thickness(sv, c[0], c[1]) # Material modifiers def iter_material_color(stroke, material_attribute): func = CurveMaterialF0D() it = stroke.stroke_vertices_begin() while not it.is_end: material = func(Interface0DIterator(it)) if material_attribute == 'DIFF': color = material.diffuse[0:3] elif material_attribute == 'SPEC': color = material.specular[0:3] else: raise ValueError("unexpected material attribute: " + material_attribute) yield it, color it.increment() def iter_material_value(stroke, material_attribute): func = CurveMaterialF0D() it = stroke.stroke_vertices_begin() while not it.is_end: material = func(Interface0DIterator(it)) if material_attribute == 'DIFF': r, g, b = material.diffuse[0:3] t = 0.35 * r + 0.45 * r + 0.2 * b elif material_attribute == 'DIFF_R': t = material.diffuse[0] elif material_attribute == 'DIFF_G': t = material.diffuse[1] elif material_attribute == 'DIFF_B': t = material.diffuse[2] elif material_attribute == 'SPEC': r, g, b = material.specular[0:3] t = 0.35 * r + 0.45 * r + 0.2 * b elif material_attribute == 'SPEC_R': t = material.specular[0] elif material_attribute == 'SPEC_G': t = material.specular[1] elif material_attribute == 'SPEC_B': t = material.specular[2] elif material_attribute == 'SPEC_HARDNESS': t = material.shininess elif material_attribute == 'ALPHA': t = material.diffuse[3] else: raise ValueError("unexpected material attribute: " + material_attribute) yield it, t it.increment() class ColorMaterialShader(ColorRampModifier): def __init__(self, blend, influence, ramp, material_attribute, use_ramp): ColorRampModifier.__init__(self, blend, influence, ramp) self.__material_attribute = material_attribute self.__use_ramp = use_ramp def shade(self, stroke): if self.__material_attribute in {'DIFF', 'SPEC'} and not self.__use_ramp: for it, b in iter_material_color(stroke, self.__material_attribute): sv = it.object a = sv.attribute.color sv.attribute.color = self.blend_ramp(a, b) else: for it, t in iter_material_value(stroke, self.__material_attribute): sv = it.object a = sv.attribute.color b = self.evaluate(t) sv.attribute.color = self.blend_ramp(a, b) class AlphaMaterialShader(CurveMappingModifier): def __init__(self, blend, influence, mapping, invert, curve, material_attribute): CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.__material_attribute = material_attribute def shade(self, stroke): for it, t in iter_material_value(stroke, self.__material_attribute): sv = it.object a = sv.attribute.alpha b = self.evaluate(t) sv.attribute.alpha = self.blend(a, b) class ThicknessMaterialShader(ThicknessBlenderMixIn, CurveMappingModifier): def __init__(self, thickness_position, thickness_ratio, blend, influence, mapping, invert, curve, material_attribute, value_min, value_max): ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio) CurveMappingModifier.__init__(self, blend, influence, mapping, invert, curve) self.__material_attribute = material_attribute self.__value_min = value_min self.__value_max = value_max def shade(self, stroke): for it, t in iter_material_value(stroke, self.__material_attribute): sv = it.object a = sv.attribute.thickness b = self.__value_min + self.evaluate(t) * (self.__value_max - self.__value_min) c = self.blend_thickness(a[0], a[1], b) self.set_thickness(sv, c[0], c[1]) # Calligraphic thickness modifier class CalligraphicThicknessShader(ThicknessBlenderMixIn, ScalarBlendModifier): def __init__(self, thickness_position, thickness_ratio, blend, influence, orientation, thickness_min, thickness_max): ThicknessBlenderMixIn.__init__(self, thickness_position, thickness_ratio) ScalarBlendModifier.__init__(self, blend, influence) self.__orientation = mathutils.Vector((math.cos(orientation), math.sin(orientation))) self.__thickness_min = thickness_min self.__thickness_max = thickness_max def shade(self, stroke): func = VertexOrientation2DF0D() it = stroke.stroke_vertices_begin() while not it.is_end: dir = func(Interface0DIterator(it)) orthDir = mathutils.Vector((-dir.y, dir.x)) orthDir.normalize() fac = abs(orthDir * self.__orientation) sv = it.object a = sv.attribute.thickness b = self.__thickness_min + fac * (self.__thickness_max - self.__thickness_min) b = max(b, 0.0) c = self.blend_thickness(a[0], a[1], b) self.set_thickness(sv, c[0], c[1]) it.increment() # Geometry modifiers def iter_distance_along_stroke(stroke): distance = 0.0 it = stroke.stroke_vertices_begin() prev = it.object.point while not it.is_end: p = it.object.point distance += (prev - p).length prev = p.copy() # need a copy because the point can be altered yield it, distance it.increment() class SinusDisplacementShader(StrokeShader): def __init__(self, wavelength, amplitude, phase): StrokeShader.__init__(self) self._wavelength = wavelength self._amplitude = amplitude self._phase = phase / wavelength * 2 * math.pi def shade(self, stroke): # separately iterate over stroke vertices to compute normals buf = [] for it, distance in iter_distance_along_stroke(stroke): buf.append((it.object, distance, stroke_normal(it))) # iterate over the vertices again to displace them for v, distance, normal in buf: n = normal * self._amplitude * math.cos(distance / self._wavelength * 2 * math.pi + self._phase) v.point = v.point + n stroke.update_length() class PerlinNoise1DShader(StrokeShader): def __init__(self, freq=10, amp=10, oct=4, angle=math.radians(45), seed=-1): StrokeShader.__init__(self) self.__noise = Noise(seed) self.__freq = freq self.__amp = amp self.__oct = oct self.__dir = mathutils.Vector((math.cos(angle), math.sin(angle))) def shade(self, stroke): length = stroke.length_2d it = stroke.stroke_vertices_begin() while not it.is_end: v = it.object nres = self.__noise.turbulence1(length * v.u, self.__freq, self.__amp, self.__oct) v.point = v.point + nres * self.__dir it.increment() stroke.update_length() class PerlinNoise2DShader(StrokeShader): def __init__(self, freq=10, amp=10, oct=4, angle=math.radians(45), seed=-1): StrokeShader.__init__(self) self.__noise = Noise(seed) self.__freq = freq self.__amp = amp self.__oct = oct self.__dir = mathutils.Vector((math.cos(angle), math.sin(angle))) 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.point + nres * self.__dir it.increment() stroke.update_length() class Offset2DShader(StrokeShader): def __init__(self, start, end, x, y): StrokeShader.__init__(self) self.__start = start self.__end = end self.__xy = mathutils.Vector((x, y)) def shade(self, stroke): # first iterate over stroke vertices to compute normals buf = [] it = stroke.stroke_vertices_begin() while not it.is_end: buf.append((it.object, stroke_normal(it))) it.increment() # again iterate over the vertices to add displacement for v, n in buf: a = self.__start + v.u * (self.__end - self.__start) n = n * a v.point = v.point + n + self.__xy stroke.update_length() class Transform2DShader(StrokeShader): def __init__(self, pivot, scale_x, scale_y, angle, pivot_u, pivot_x, pivot_y): StrokeShader.__init__(self) self.__pivot = pivot self.__scale_x = scale_x self.__scale_y = scale_y self.__angle = angle self.__pivot_u = pivot_u self.__pivot_x = pivot_x self.__pivot_y = pivot_y def shade(self, stroke): # determine the pivot of scaling and rotation operations if self.__pivot == 'START': it = stroke.stroke_vertices_begin() pivot = it.object.point elif self.__pivot == 'END': it = stroke.stroke_vertices_end() it.decrement() pivot = it.object.point elif self.__pivot == 'PARAM': p = None it = stroke.stroke_vertices_begin() while not it.is_end: prev = p v = it.object p = v.point u = v.u if self.__pivot_u < u: break it.increment() if prev is None: pivot = p else: delta = u - self.__pivot_u pivot = p + delta * (prev - p) elif self.__pivot == 'CENTER': pivot = mathutils.Vector((0.0, 0.0)) n = 0 it = stroke.stroke_vertices_begin() while not it.is_end: p = it.object.point pivot = pivot + p n += 1 it.increment() pivot.x = pivot.x / n pivot.y = pivot.y / n elif self.__pivot == 'ABSOLUTE': pivot = mathutils.Vector((self.__pivot_x, self.__pivot_y)) # apply scaling and rotation operations cos_theta = math.cos(self.__angle) sin_theta = math.sin(self.__angle) it = stroke.stroke_vertices_begin() while not it.is_end: v = it.object p = v.point p = p - pivot x = p.x * self.__scale_x y = p.y * self.__scale_y p.x = x * cos_theta - y * sin_theta p.y = x * sin_theta + y * cos_theta v.point = p + pivot it.increment() stroke.update_length() # Predicates and helper functions class QuantitativeInvisibilityRangeUP1D(UnaryPredicate1D): def __init__(self, qi_start, qi_end): UnaryPredicate1D.__init__(self) self.__getQI = QuantitativeInvisibilityF1D() self.__qi_start = qi_start self.__qi_end = qi_end def __call__(self, inter): qi = self.__getQI(inter) return self.__qi_start <= qi <= self.__qi_end def join_unary_predicates(upred_list, bpred): if not upred_list: return None upred = upred_list[0] for p in upred_list[1:]: upred = bpred(upred, p) return upred class ObjectNamesUP1D(UnaryPredicate1D): def __init__(self, names, negative): UnaryPredicate1D.__init__(self) self._names = names self._negative = negative def __call__(self, viewEdge): found = viewEdge.viewshape.name in self._names if self._negative: return not found return found # Stroke caps def iter_stroke_vertices(stroke): it = stroke.stroke_vertices_begin() prev_p = None while not it.is_end: sv = it.object p = sv.point if prev_p is None or (prev_p - p).length > 1e-6: yield sv prev_p = p.copy() it.increment() class RoundCapShader(StrokeShader): def round_cap_thickness(self, x): x = max(0.0, min(x, 1.0)) return math.sqrt(1.0 - (x ** 2.0)) def shade(self, stroke): # save the location and attribute of stroke vertices buffer = [] for sv in iter_stroke_vertices(stroke): buffer.append((mathutils.Vector(sv.point), StrokeAttribute(sv.attribute))) nverts = len(buffer) if nverts < 2: return # calculate the number of additional vertices to form caps R, L = stroke[0].attribute.thickness caplen_beg = (R + L) / 2.0 nverts_beg = max(5, int(R + L)) R, L = stroke[-1].attribute.thickness caplen_end = (R + L) / 2.0 nverts_end = max(5, int(R + L)) # adjust the total number of stroke vertices stroke.resample(nverts + nverts_beg + nverts_end) # restore the location and attribute of the original vertices for i in range(nverts): p, attr = buffer[i] stroke[nverts_beg + i].point = p stroke[nverts_beg + i].attribute = attr # reshape the cap at the beginning of the stroke q, attr = buffer[1] p, attr = buffer[0] d = p - q d = d / d.length * caplen_beg n = 1.0 / nverts_beg R, L = attr.thickness for i in range(nverts_beg): t = (nverts_beg - i) * n stroke[i].point = p + d * t r = self.round_cap_thickness((nverts_beg - i + 1) * n) stroke[i].attribute = attr stroke[i].attribute.thickness = (R * r, L * r) # reshape the cap at the end of the stroke q, attr = buffer[-2] p, attr = buffer[-1] d = p - q d = d / d.length * caplen_end n = 1.0 / nverts_end R, L = attr.thickness for i in range(nverts_end): t = (nverts_end - i) * n stroke[-i - 1].point = p + d * t r = self.round_cap_thickness((nverts_end - i + 1) * n) stroke[-i - 1].attribute = attr stroke[-i - 1].attribute.thickness = (R * r, L * r) # update the curvilinear 2D length of each vertex stroke.update_length() class SquareCapShader(StrokeShader): def shade(self, stroke): # save the location and attribute of stroke vertices buffer = [] for sv in iter_stroke_vertices(stroke): buffer.append((mathutils.Vector(sv.point), StrokeAttribute(sv.attribute))) nverts = len(buffer) if nverts < 2: return # calculate the number of additional vertices to form caps R, L = stroke[0].attribute.thickness caplen_beg = (R + L) / 2.0 nverts_beg = 1 R, L = stroke[-1].attribute.thickness caplen_end = (R + L) / 2.0 nverts_end = 1 # adjust the total number of stroke vertices stroke.resample(nverts + nverts_beg + nverts_end) # restore the location and attribute of the original vertices for i in range(nverts): p, attr = buffer[i] stroke[nverts_beg + i].point = p stroke[nverts_beg + i].attribute = attr # reshape the cap at the beginning of the stroke q, attr = buffer[1] p, attr = buffer[0] d = p - q stroke[0].point = p + d / d.length * caplen_beg stroke[0].attribute = attr # reshape the cap at the end of the stroke q, attr = buffer[-2] p, attr = buffer[-1] d = p - q stroke[-1].point = p + d / d.length * caplen_beg stroke[-1].attribute = attr # update the curvilinear 2D length of each vertex stroke.update_length() # Split by dashed line pattern class SplitPatternStartingUP0D(UnaryPredicate0D): def __init__(self, controller): UnaryPredicate0D.__init__(self) self._controller = controller def __call__(self, inter): return self._controller.start() class SplitPatternStoppingUP0D(UnaryPredicate0D): def __init__(self, controller): UnaryPredicate0D.__init__(self) self._controller = controller def __call__(self, inter): return self._controller.stop() class SplitPatternController: def __init__(self, pattern, sampling): self.sampling = float(sampling) k = len(pattern) // 2 n = k * 2 self.start_pos = [pattern[i] + pattern[i + 1] for i in range(0, n, 2)] self.stop_pos = [pattern[i] for i in range(0, n, 2)] self.init() def init(self): self.start_len = 0.0 self.start_idx = 0 self.stop_len = self.sampling self.stop_idx = 0 def start(self): self.start_len += self.sampling if abs(self.start_len - self.start_pos[self.start_idx]) < self.sampling / 2.0: self.start_len = 0.0 self.start_idx = (self.start_idx + 1) % len(self.start_pos) return True return False def stop(self): if self.start_len > 0.0: self.init() self.stop_len += self.sampling if abs(self.stop_len - self.stop_pos[self.stop_idx]) < self.sampling / 2.0: self.stop_len = self.sampling self.stop_idx = (self.stop_idx + 1) % len(self.stop_pos) return True return False # Dashed line class DashedLineShader(StrokeShader): def __init__(self, pattern): StrokeShader.__init__(self) self._pattern = pattern def shade(self, stroke): index = 0 # pattern index start = 0.0 # 2D curvilinear length visible = True sampling = 1.0 it = stroke.stroke_vertices_begin(sampling) while not it.is_end: pos = it.t # curvilinear abscissa # The extra 'sampling' term is added below, because the # visibility attribute of the i-th vertex refers to the # visibility of the stroke segment between the i-th and # (i+1)-th vertices. if pos - start + sampling > self._pattern[index]: start = pos index += 1 if index == len(self._pattern): index = 0 visible = not visible it.object.attribute.visible = visible it.increment() # predicates for chaining class AngleLargerThanBP1D(BinaryPredicate1D): def __init__(self, angle): BinaryPredicate1D.__init__(self) self._angle = angle def __call__(self, i1, i2): sv1a = i1.first_fedge.first_svertex.point_2d sv1b = i1.last_fedge.second_svertex.point_2d sv2a = i2.first_fedge.first_svertex.point_2d sv2b = i2.last_fedge.second_svertex.point_2d if (sv1a - sv2a).length < 1e-6: dir1 = sv1a - sv1b dir2 = sv2b - sv2a elif (sv1b - sv2b).length < 1e-6: dir1 = sv1b - sv1a dir2 = sv2a - sv2b elif (sv1a - sv2b).length < 1e-6: dir1 = sv1a - sv1b dir2 = sv2a - sv2b elif (sv1b - sv2a).length < 1e-6: dir1 = sv1b - sv1a dir2 = sv2b - sv2a else: return False denom = dir1.length * dir2.length if denom < 1e-6: return False x = (dir1 * dir2) / denom return math.acos(min(max(x, -1.0), 1.0)) > self._angle class AndBP1D(BinaryPredicate1D): def __init__(self, pred1, pred2): BinaryPredicate1D.__init__(self) self.__pred1 = pred1 self.__pred2 = pred2 def __call__(self, i1, i2): return self.__pred1(i1, i2) and self.__pred2(i1, i2) # predicates for selection class LengthThresholdUP1D(UnaryPredicate1D): def __init__(self, length_min=None, length_max=None): UnaryPredicate1D.__init__(self) self._length_min = length_min self._length_max = length_max def __call__(self, inter): length = inter.length_2d if self._length_min is not None and length < self._length_min: return False if self._length_max is not None and length > self._length_max: return False return True class FaceMarkBothUP1D(UnaryPredicate1D): def __call__(self, inter): # ViewEdge fe = inter.first_fedge while fe is not None: if fe.is_smooth: if fe.face_mark: return True elif (fe.nature & Nature.BORDER): if fe.face_mark_left: return True else: if fe.face_mark_right and fe.face_mark_left: return True fe = fe.next_fedge return False class FaceMarkOneUP1D(UnaryPredicate1D): def __call__(self, inter): # ViewEdge fe = inter.first_fedge while fe is not None: if fe.is_smooth: if fe.face_mark: return True elif (fe.nature & Nature.BORDER): if fe.face_mark_left: return True else: if fe.face_mark_right or fe.face_mark_left: return True fe = fe.next_fedge return False # predicates for splitting class MaterialBoundaryUP0D(UnaryPredicate0D): def __call__(self, it): if it.is_begin: return False it_prev = Interface0DIterator(it) it_prev.decrement() v = it.object it.increment() if it.is_end: return False fe = v.get_fedge(it_prev.object) idx1 = fe.material_index if fe.is_smooth else fe.material_index_left fe = v.get_fedge(it.object) idx2 = fe.material_index if fe.is_smooth else fe.material_index_left return idx1 != idx2 class Curvature2DAngleThresholdUP0D(UnaryPredicate0D): def __init__(self, angle_min=None, angle_max=None): UnaryPredicate0D.__init__(self) self._angle_min = angle_min self._angle_max = angle_max self._func = Curvature2DAngleF0D() def __call__(self, inter): angle = math.pi - self._func(inter) if self._angle_min is not None and angle < self._angle_min: return True if self._angle_max is not None and angle > self._angle_max: return True return False class Length2DThresholdUP0D(UnaryPredicate0D): def __init__(self, length_limit): UnaryPredicate0D.__init__(self) self._length_limit = length_limit self._t = 0.0 def __call__(self, inter): t = inter.t # curvilinear abscissa if t < self._t: self._t = 0.0 return False if t - self._t < self._length_limit: return False self._t = t return True # Seed for random number generation class Seed: def __init__(self): self.t_max = 2 ** 15 self.t = int(time.time()) % self.t_max def get(self, seed): if seed < 0: self.t = (self.t + 1) % self.t_max return self.t return seed _seed = Seed() ### T.K. 07-Aug-2013 Temporary fix for unexpected line gaps def iter_three_segments(stroke): n = stroke.stroke_vertices_size() if n >= 4: it1 = stroke.stroke_vertices_begin() it2 = stroke.stroke_vertices_begin() it2.increment() it3 = stroke.stroke_vertices_begin() it3.increment() it3.increment() it4 = stroke.stroke_vertices_begin() it4.increment() it4.increment() it4.increment() while not it4.is_end: yield (it1.object, it2.object, it3.object, it4.object) it1.increment() it2.increment() it3.increment() it4.increment() def is_tvertex(svertex): return type(svertex.viewvertex) is TVertex class StrokeCleaner(StrokeShader): def shade(self, stroke): for sv1, sv2, sv3, sv4 in iter_three_segments(stroke): seg1 = sv2.point - sv1.point seg2 = sv3.point - sv2.point seg3 = sv4.point - sv3.point if not ((is_tvertex(sv2.first_svertex) and is_tvertex(sv2.second_svertex)) or (is_tvertex(sv3.first_svertex) and is_tvertex(sv3.second_svertex))): continue if seg1.dot(seg2) < 0.0 and seg2.dot(seg3) < 0.0 and seg2.length < 0.01: #print(sv2.first_svertex.viewvertex) #print(sv2.second_svertex.viewvertex) #print(sv3.first_svertex.viewvertex) #print(sv3.second_svertex.viewvertex) p2 = mathutils.Vector(sv2.point) p3 = mathutils.Vector(sv3.point) sv2.point = p3 sv3.point = p2 stroke.update_length() integration_types = { 'MEAN': IntegrationType.MEAN, 'MIN': IntegrationType.MIN, 'MAX': IntegrationType.MAX, 'FIRST': IntegrationType.FIRST, 'LAST': IntegrationType.LAST} # main function for parameter processing def process(layer_name, lineset_name): scene = getCurrentScene() layer = scene.render.layers[layer_name] lineset = layer.freestyle_settings.linesets[lineset_name] linestyle = lineset.linestyle selection_criteria = [] # prepare selection criteria by visibility if lineset.select_by_visibility: if lineset.visibility == 'VISIBLE': selection_criteria.append( QuantitativeInvisibilityUP1D(0)) elif lineset.visibility == 'HIDDEN': selection_criteria.append( NotUP1D(QuantitativeInvisibilityUP1D(0))) elif lineset.visibility == 'RANGE': selection_criteria.append( QuantitativeInvisibilityRangeUP1D(lineset.qi_start, lineset.qi_end)) # prepare selection criteria by edge types if lineset.select_by_edge_types: edge_type_criteria = [] if lineset.select_silhouette: upred = pyNatureUP1D(Nature.SILHOUETTE) edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_silhouette else upred) if lineset.select_border: upred = pyNatureUP1D(Nature.BORDER) edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_border else upred) if lineset.select_crease: upred = pyNatureUP1D(Nature.CREASE) edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_crease else upred) if lineset.select_ridge_valley: upred = pyNatureUP1D(Nature.RIDGE) edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_ridge_valley else upred) if lineset.select_suggestive_contour: upred = pyNatureUP1D(Nature.SUGGESTIVE_CONTOUR) edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_suggestive_contour else upred) if lineset.select_material_boundary: upred = pyNatureUP1D(Nature.MATERIAL_BOUNDARY) edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_material_boundary else upred) if lineset.select_edge_mark: upred = pyNatureUP1D(Nature.EDGE_MARK) edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_edge_mark else upred) if lineset.select_contour: upred = ContourUP1D() edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_contour else upred) if lineset.select_external_contour: upred = ExternalContourUP1D() edge_type_criteria.append(NotUP1D(upred) if lineset.exclude_external_contour else upred) if lineset.edge_type_combination == 'OR': upred = join_unary_predicates(edge_type_criteria, OrUP1D) else: upred = join_unary_predicates(edge_type_criteria, AndUP1D) if upred is not None: if lineset.edge_type_negation == 'EXCLUSIVE': upred = NotUP1D(upred) selection_criteria.append(upred) # prepare selection criteria by face marks if lineset.select_by_face_marks: if lineset.face_mark_condition == 'BOTH': upred = FaceMarkBothUP1D() else: upred = FaceMarkOneUP1D() if lineset.face_mark_negation == 'EXCLUSIVE': upred = NotUP1D(upred) selection_criteria.append(upred) # prepare selection criteria by group of objects if lineset.select_by_group: if lineset.group is not None: names = dict((ob.name, True) for ob in lineset.group.objects) upred = ObjectNamesUP1D(names, lineset.group_negation == 'EXCLUSIVE') selection_criteria.append(upred) # prepare selection criteria by image border if lineset.select_by_image_border: xmin, ymin, xmax, ymax = ContextFunctions.get_border() upred = WithinImageBoundaryUP1D(xmin, ymin, xmax, ymax) selection_criteria.append(upred) # select feature edges upred = join_unary_predicates(selection_criteria, AndUP1D) if upred is None: upred = TrueUP1D() Operators.select(upred) # join feature edges to form chains if linestyle.use_chaining: if linestyle.chaining == 'PLAIN': if linestyle.use_same_object: Operators.bidirectional_chain(ChainSilhouetteIterator(), NotUP1D(upred)) else: Operators.bidirectional_chain(ChainPredicateIterator(upred, TrueBP1D()), NotUP1D(upred)) elif linestyle.chaining == 'SKETCHY': if linestyle.use_same_object: Operators.bidirectional_chain(pySketchyChainSilhouetteIterator(linestyle.rounds)) else: Operators.bidirectional_chain(pySketchyChainingIterator(linestyle.rounds)) else: Operators.chain(ChainPredicateIterator(FalseUP1D(), FalseBP1D()), NotUP1D(upred)) # split chains if linestyle.material_boundary: Operators.sequential_split(MaterialBoundaryUP0D()) if linestyle.use_angle_min or linestyle.use_angle_max: angle_min = linestyle.angle_min if linestyle.use_angle_min else None angle_max = linestyle.angle_max if linestyle.use_angle_max else None Operators.sequential_split(Curvature2DAngleThresholdUP0D(angle_min, angle_max)) if linestyle.use_split_length: Operators.sequential_split(Length2DThresholdUP0D(linestyle.split_length), 1.0) if linestyle.use_split_pattern: pattern = [] if linestyle.split_dash1 > 0 and linestyle.split_gap1 > 0: pattern.append(linestyle.split_dash1) pattern.append(linestyle.split_gap1) if linestyle.split_dash2 > 0 and linestyle.split_gap2 > 0: pattern.append(linestyle.split_dash2) pattern.append(linestyle.split_gap2) if linestyle.split_dash3 > 0 and linestyle.split_gap3 > 0: pattern.append(linestyle.split_dash3) pattern.append(linestyle.split_gap3) if len(pattern) > 0: sampling = 1.0 controller = SplitPatternController(pattern, sampling) Operators.sequential_split(SplitPatternStartingUP0D(controller), SplitPatternStoppingUP0D(controller), sampling) # select chains if linestyle.use_length_min or linestyle.use_length_max: length_min = linestyle.length_min if linestyle.use_length_min else None length_max = linestyle.length_max if linestyle.use_length_max else None Operators.select(LengthThresholdUP1D(length_min, length_max)) # sort selected chains if linestyle.use_sorting: integration = integration_types.get(linestyle.integration_type, IntegrationType.MEAN) if linestyle.sort_key == 'DISTANCE_FROM_CAMERA': bpred = pyZBP1D(integration) elif linestyle.sort_key == '2D_LENGTH': bpred = Length2DBP1D() if linestyle.sort_order == 'REVERSE': bpred = NotBP1D(bpred) Operators.sort(bpred) # prepare a list of stroke shaders shaders_list = [] ### shaders_list.append(StrokeCleaner()) ### for m in linestyle.geometry_modifiers: if not m.use: continue if m.type == 'SAMPLING': shaders_list.append(SamplingShader( m.sampling)) elif m.type == 'BEZIER_CURVE': shaders_list.append(BezierCurveShader( m.error)) elif m.type == 'SINUS_DISPLACEMENT': shaders_list.append(SinusDisplacementShader( m.wavelength, m.amplitude, m.phase)) elif m.type == 'SPATIAL_NOISE': shaders_list.append(SpatialNoiseShader( m.amplitude, m.scale, m.octaves, m.smooth, m.use_pure_random)) elif m.type == 'PERLIN_NOISE_1D': shaders_list.append(PerlinNoise1DShader( m.frequency, m.amplitude, m.octaves, m.angle, _seed.get(m.seed))) elif m.type == 'PERLIN_NOISE_2D': shaders_list.append(PerlinNoise2DShader( m.frequency, m.amplitude, m.octaves, m.angle, _seed.get(m.seed))) elif m.type == 'BACKBONE_STRETCHER': shaders_list.append(BackboneStretcherShader( m.backbone_length)) elif m.type == 'TIP_REMOVER': shaders_list.append(TipRemoverShader( m.tip_length)) elif m.type == 'POLYGONIZATION': shaders_list.append(PolygonalizationShader( m.error)) elif m.type == 'GUIDING_LINES': shaders_list.append(GuidingLinesShader( m.offset)) elif m.type == 'BLUEPRINT': if m.shape == 'CIRCLES': shaders_list.append(pyBluePrintCirclesShader( m.rounds, m.random_radius, m.random_center)) elif m.shape == 'ELLIPSES': shaders_list.append(pyBluePrintEllipsesShader( m.rounds, m.random_radius, m.random_center)) elif m.shape == 'SQUARES': shaders_list.append(pyBluePrintSquaresShader( m.rounds, m.backbone_length, m.random_backbone)) elif m.type == '2D_OFFSET': shaders_list.append(Offset2DShader( m.start, m.end, m.x, m.y)) elif m.type == '2D_TRANSFORM': shaders_list.append(Transform2DShader( m.pivot, m.scale_x, m.scale_y, m.angle, m.pivot_u, m.pivot_x, m.pivot_y)) color = linestyle.color if linestyle.use_texture: has_tex = False for slot in linestyle.texture_slots: if slot is not None: shaders_list.append(BlenderTextureShader(slot)) has_tex = True if has_tex: shaders_list.append(StrokeTextureStepShader(linestyle.texture_spacing)) if (not linestyle.use_chaining) or (linestyle.chaining == 'PLAIN' and linestyle.use_same_object): thickness_position = linestyle.thickness_position else: thickness_position = 'CENTER' import bpy if bpy.app.debug_freestyle: print("Warning: Thickness position options are applied when chaining is disabled\n" " or the Plain chaining is used with the Same Object option enabled.") shaders_list.append(BaseColorShader(color.r, color.g, color.b, linestyle.alpha)) shaders_list.append(BaseThicknessShader(linestyle.thickness, thickness_position, linestyle.thickness_ratio)) for m in linestyle.color_modifiers: if not m.use: continue if m.type == 'ALONG_STROKE': shaders_list.append(ColorAlongStrokeShader( m.blend, m.influence, m.color_ramp)) elif m.type == 'DISTANCE_FROM_CAMERA': shaders_list.append(ColorDistanceFromCameraShader( m.blend, m.influence, m.color_ramp, m.range_min, m.range_max)) elif m.type == 'DISTANCE_FROM_OBJECT': shaders_list.append(ColorDistanceFromObjectShader( m.blend, m.influence, m.color_ramp, m.target, m.range_min, m.range_max)) elif m.type == 'MATERIAL': shaders_list.append(ColorMaterialShader( m.blend, m.influence, m.color_ramp, m.material_attribute, m.use_ramp)) for m in linestyle.alpha_modifiers: if not m.use: continue if m.type == 'ALONG_STROKE': shaders_list.append(AlphaAlongStrokeShader( m.blend, m.influence, m.mapping, m.invert, m.curve)) elif m.type == 'DISTANCE_FROM_CAMERA': shaders_list.append(AlphaDistanceFromCameraShader( m.blend, m.influence, m.mapping, m.invert, m.curve, m.range_min, m.range_max)) elif m.type == 'DISTANCE_FROM_OBJECT': shaders_list.append(AlphaDistanceFromObjectShader( m.blend, m.influence, m.mapping, m.invert, m.curve, m.target, m.range_min, m.range_max)) elif m.type == 'MATERIAL': shaders_list.append(AlphaMaterialShader( m.blend, m.influence, m.mapping, m.invert, m.curve, m.material_attribute)) for m in linestyle.thickness_modifiers: if not m.use: continue if m.type == 'ALONG_STROKE': shaders_list.append(ThicknessAlongStrokeShader( thickness_position, linestyle.thickness_ratio, m.blend, m.influence, m.mapping, m.invert, m.curve, m.value_min, m.value_max)) elif m.type == 'DISTANCE_FROM_CAMERA': shaders_list.append(ThicknessDistanceFromCameraShader( thickness_position, linestyle.thickness_ratio, m.blend, m.influence, m.mapping, m.invert, m.curve, m.range_min, m.range_max, m.value_min, m.value_max)) elif m.type == 'DISTANCE_FROM_OBJECT': shaders_list.append(ThicknessDistanceFromObjectShader( thickness_position, linestyle.thickness_ratio, m.blend, m.influence, m.mapping, m.invert, m.curve, m.target, m.range_min, m.range_max, m.value_min, m.value_max)) elif m.type == 'MATERIAL': shaders_list.append(ThicknessMaterialShader( thickness_position, linestyle.thickness_ratio, m.blend, m.influence, m.mapping, m.invert, m.curve, m.material_attribute, m.value_min, m.value_max)) elif m.type == 'CALLIGRAPHY': shaders_list.append(CalligraphicThicknessShader( thickness_position, linestyle.thickness_ratio, m.blend, m.influence, m.orientation, m.thickness_min, m.thickness_max)) if linestyle.caps == 'ROUND': shaders_list.append(RoundCapShader()) elif linestyle.caps == 'SQUARE': shaders_list.append(SquareCapShader()) if linestyle.use_dashed_line: pattern = [] if linestyle.dash1 > 0 and linestyle.gap1 > 0: pattern.append(linestyle.dash1) pattern.append(linestyle.gap1) if linestyle.dash2 > 0 and linestyle.gap2 > 0: pattern.append(linestyle.dash2) pattern.append(linestyle.gap2) if linestyle.dash3 > 0 and linestyle.gap3 > 0: pattern.append(linestyle.dash3) pattern.append(linestyle.gap3) if len(pattern) > 0: shaders_list.append(DashedLineShader(pattern)) # create strokes using the shaders list Operators.create(TrueUP1D(), shaders_list)