release/scripts/startup/bl_operators/vertexpaint_dirt.py

   1 # ***** BEGIN GPL LICENSE BLOCK *****
   2 #
   3 # Script copyright (C) Campbell J Barton
   4 #
   5 # This program is free software; you can redistribute it and/or
   6 # modify it under the terms of the GNU General Public License
   7 # as published by the Free Software Foundation; either version 2
   8 # of the License, or (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program; if not, write to the Free Software Foundation,
  17 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18 #
  19 # ***** END GPL LICENCE BLOCK *****
  20 # --------------------------------------------------------------------------
  21
  22 # <pep8 compliant>
  23
  24 # History
  25 #
  26 # Originally written by Campbell Barton aka ideasman42
  27 #
  28 # 2009-11-01: * 2.5 port by Keith "Wahooney" Boshoff
  29 #              * Replaced old method with my own, speed is similar (about 0.001 sec on Suzanne)
  30 #               but results are far more accurate
  31 #
  32
  33
  34 def applyVertexDirt(me, blur_iterations, blur_strength, clamp_dirt, clamp_clean, dirt_only):
  35     from mathutils import Vector
  36     from math import acos
  37
  38     #BPyMesh.meshCalcNormals(me)
  39
  40     vert_tone = [0.0] * len(me.vertices)
  41
  42     min_tone = 180.0
  43     max_tone = 0.0
  44
  45     # create lookup table for each vertex's connected vertices (via edges)
  46     con = []
  47
  48     con = [[] for i in range(len(me.vertices))]
  49
  50     # add connected verts
  51     for e in me.edges:
  52         con[e.vertices[0]].append(e.vertices[1])
  53         con[e.vertices[1]].append(e.vertices[0])
  54
  55     for i, v in enumerate(me.vertices):
  56         vec = Vector()
  57         no = v.normal
  58         co = v.co
  59
  60         # get the direction of the vectors between the vertex and it's connected vertices
  61         for c in con[i]:
  62             vec += (me.vertices[c].co - co).normalized()
  63
  64         # normalize the vector by dividing by the number of connected verts
  65         tot_con = len(con[i])
  66
  67         if tot_con == 0:
  68             continue
  69
  70         vec /= tot_con
  71
  72         # angle is the acos of the dot product between vert and connected verts normals
  73         ang = acos(no.dot(vec))
  74
  75         # enforce min/max
  76         ang = max(clamp_dirt, ang)
  77
  78         if not dirt_only:
  79             ang = min(clamp_clean, ang)
  80
  81         vert_tone[i] = ang
  82
  83     # blur tones
  84     for i in range(blur_iterations):
  85         # backup the original tones
  86         orig_vert_tone = list(vert_tone)
  87
  88         # use connected verts look up for blurring
  89         for j, c in enumerate(con):
  90             for v in c:
  91                 vert_tone[j] += blur_strength * orig_vert_tone[v]
  92
  93             vert_tone[j] /= len(c) * blur_strength + 1
  94
  95     min_tone = min(vert_tone)
  96     max_tone = max(vert_tone)
  97
  98     # debug information
  99     # print(min_tone * 2 * math.pi)
 100     # print(max_tone * 2 * math.pi)
 101     # print(clamp_clean)
 102     # print(clamp_dirt)
 103
 104     tone_range = max_tone - min_tone
 105
 106     if not tone_range:
 107         return
 108
 109     active_col_layer = None
 110
 111     if len(me.vertex_colors):
 112         for lay in me.vertex_colors:
 113             if lay.active:
 114                 active_col_layer = lay.data
 115     else:
 116         bpy.ops.mesh.vertex_color_add()
 117         me.vertex_colors[0].active = True
 118         active_col_layer = me.vertex_colors[0].data
 119
 120     if not active_col_layer:
 121         return('CANCELLED', )
 122
 123     for i, f in enumerate(me.faces):
 124         if not me.use_paint_mask or f.select:
 125
 126             f_col = active_col_layer[i]
 127
 128             f_col = [f_col.color1, f_col.color2, f_col.color3, f_col.color4]
 129
 130             for j, v in enumerate(f.vertices):
 131                 col = f_col[j]
 132                 tone = vert_tone[me.vertices[v].index]
 133                 tone = (tone - min_tone) / tone_range
 134
 135                 if dirt_only:
 136                     tone = min(tone, 0.5)
 137                     tone *= 2
 138
 139                 col[0] = tone * col[0]
 140                 col[1] = tone * col[1]
 141                 col[2] = tone * col[2]
 142
 143
 144 import bpy
 145 from bpy.types import Operator
 146 from bpy.props import FloatProperty, IntProperty, BoolProperty
 147
 148
 149 class VertexPaintDirt(Operator):
 150     bl_idname = "paint.vertex_color_dirt"
 151     bl_label = "Dirty Vertex Colors"
 152     bl_options = {'REGISTER', 'UNDO'}
 153
 154     blur_strength = FloatProperty(name="Blur Strength", description="Blur strength per iteration", default=1.0, min=0.01, max=1.0)
 155     blur_iterations = IntProperty(name="Blur Iterations", description="Number times to blur the colors. (higher blurs more)", default=1, min=0, max=40)
 156     clean_angle = FloatProperty(name="Highlight Angle", description="Less then 90 limits the angle used in the tonal range", default=180.0, min=0.0, max=180.0)
 157     dirt_angle = FloatProperty(name="Dirt Angle", description="Less then 90 limits the angle used in the tonal range", default=0.0, min=0.0, max=180.0)
 158     dirt_only = BoolProperty(name="Dirt Only", description="Dont calculate cleans for convex areas", default=False)
 159
 160     def execute(self, context):
 161         import time
 162         from math import radians
 163         obj = context.object
 164
 165         if not obj or obj.type != 'MESH':
 166             self.report({'ERROR'}, "Error, no active mesh object, aborting")
 167             return {'CANCELLED'}
 168
 169         mesh = obj.data
 170
 171         t = time.time()
 172
 173         applyVertexDirt(mesh, self.blur_iterations, self.blur_strength, radians(self.dirt_angle), radians(self.clean_angle), self.dirt_only)
 174
 175         print('Dirt calculated in %.6f' % (time.time() - t))
 176
 177         return {'FINISHED'}