def execute(self,context): if bpy.context.mode == 'OBJECT': bme = bmesh.new() bme.from_mesh(bpy.context.object.data) bme.verts.ensure_lookup_table() bme.edges.ensure_lookup_table() bme.faces.ensure_lookup_table() elif context.mode == 'EDIT': bme = bmesh.from_edit_mesh(bpy.context.object.data) else: self.report({'ERROR'}, 'Must be in Object or Edit Mode') bme.verts.ensure_lookup_table() bme.edges.ensure_lookup_table() bme.faces.ensure_lookup_table() selected_verts = [v for v in bme.verts if v.select] islands = bmesh_loose_parts_verts(bme, selected_verts, max_iters = 100) biggest = max(islands, key = len) if "AO_select" in bme.loops.layers.color: ao_select_color_layer = bme.loops.layers.color["AO_select"] red = Color((1,0,0)) white = Color((1,1,1)) for v in bme.verts: if v in biggest: v.select_set(True) for f in v.link_faces: for loop in f.loops: if loop.vert == v: loop[ao_select_color_layer] = red else: v.select_set(False) for f in v.link_faces: for loop in f.loops: if loop.vert == v: loop[ao_select_color_layer] = white if bpy.context.mode == 'OBJECT': bme.to_mesh(bpy.context.object.data) bme.free() else: bmesh.update_edit_mesh(bpy.context.object.data) return {'FINISHED'}
def convert(value, method): if method == 'BW2W': return (value.r + value.g + value.b) / 3 elif method == 'W2BW': col = Color((value, value, value)) return col elif method == 'HSV2W': return 1 - (value.h / 0.66) elif method == 'W2HSV': col = Color() col.hsv = (0.66 * (1 - value), 1, 1) return col
class Button(bge.types.KX_PythonComponent): args = { "Activate": True, "Pressed Message": "", "Released Message": "", "Normal Color": Color([0.7, 0.7, 0.7, 1.0]), "Highlighted Color": Color([1.0, 1.0, 1.0, 1.0]), "Pressed Color": Color([0.5, 0.5, 0.5, 1.0]), "Disabled Color": Color([0.2, 0.2, 0.2, 1.0]), } def start(self, args): self.active = args["Activate"] self.pressedFunction = None self.releasedFunction = None self.pressedMessage = args["Pressed Message"] self.releasedMessage = args["Released Message"] self.normalColor = args["Normal Color"] self.highlightedColor = args["Highlighted Color"] self.pressedColor = args["Pressed Color"] self.disabledColor = args["Disabled Color"] self.materials = [] for mesh in self.object.meshes: for material in mesh.materials: self.materials.append(material) self.object["Button Component"] = True def __mouseOver(self): scene = bge.logic.getCurrentScene() cam = scene.active_camera mPos = bge.logic.mouse.position obj = cam.getScreenRay(mPos[0], mPos[1], 10000, "Button Component") return obj == self.object def update(self): over = self.__mouseOver() if self.active: if over: if bge.logic.mouse.inputs[bge.events.LEFTMOUSE].values[-1]: self.object.color = self.pressedColor else: self.object.color = self.highlightedColor else: self.object.color = self.normalColor else: self.object.color = self.disabledColor
def __init__(self, light, meshesAndNodes): if light.parent and light.parent.type != 'ARMATURE': self.parentId = light.parent.name self.name = light.name Logger.log('processing begun of light (' + light.data.type + '): ' + self.name) self.define_animations(light, False, True, False) light_type_items = {'POINT': POINT_LIGHT, 'SUN': DIRECTIONAL_LIGHT, 'SPOT': SPOT_LIGHT, 'HEMI': HEMI_LIGHT, 'AREA': POINT_LIGHT} self.light_type = light_type_items[light.data.type] if self.light_type == POINT_LIGHT: self.position = light.location if hasattr(light.data, 'use_sphere'): if light.data.use_sphere: self.range = light.data.distance elif self.light_type == DIRECTIONAL_LIGHT: self.position = light.location self.direction = Light.get_direction(light.matrix_local) elif self.light_type == SPOT_LIGHT: self.position = light.location self.direction = Light.get_direction(light.matrix_local) self.angle = light.data.spot_size self.exponent = light.data.spot_blend * 2 if light.data.use_sphere: self.range = light.data.distance else: # Hemi matrix_local = light.matrix_local.copy() matrix_local.translation = Vector((0, 0, 0)) self.direction = (Vector((0, 0, -1)) * matrix_local) self.direction = scale_vector(self.direction, -1) self.groundColor = Color((0, 0, 0)) self.intensity = light.data.energy self.diffuse = light.data.color if light.data.use_diffuse else Color((0, 0, 0)) self.specular = light.data.color if light.data.use_specular else Color((0, 0, 0)) #code generated for cameraLight is done in js_exporter self.cameraLight = light.data.cameraLight # inclusion section if light.data.use_own_layer: lampLayer = getLayer(light) self.includedOnlyMeshesIds = [] for mesh in meshesAndNodes: if mesh.layer == lampLayer: self.includedOnlyMeshesIds.append(mesh.name)
def loadBasicMaterials(): ''' Define some basic materials for easy "coloring". ''' if 'red' not in [i.name for i in bpy.data.materials]: material = bpy.data.materials.new('red') material.diffuse_color = Color((1, 0, 0)) if 'green' not in [i.name for i in bpy.data.materials]: material = bpy.data.materials.new('green') material.diffuse_color = Color((0, 1, 0)) if 'blue' not in [i.name for i in bpy.data.materials]: material = bpy.data.materials.new('blue') material.diffuse_color = Color((0, 0, 1)) if 'cyan' not in [i.name for i in bpy.data.materials]: material = bpy.data.materials.new('cyan') material.diffuse_color = Color((0, 1, 1)) if 'magenta' not in [i.name for i in bpy.data.materials]: material = bpy.data.materials.new('magenta') material.diffuse_color = Color((1, 0, 1)) if 'yellow' not in [i.name for i in bpy.data.materials]: material = bpy.data.materials.new('yellow') material.diffuse_color = Color((1, 1, 0)) if 'black' not in [i.name for i in bpy.data.materials]: material = bpy.data.materials.new('black') material.diffuse_color = Color((0, 0, 0)) if 'white' not in [i.name for i in bpy.data.materials]: material = bpy.data.materials.new('white') material.diffuse_color = Color((1, 1, 1))
def vertex_color(context): threshold = .1 if len(context.selected_objects) == 0: return obj = context.selected_objects[0] bpy.ops.object.mode_set(mode="OBJECT") colors = obj.data.vertex_colors.active.data #selected_polygons = list(filter(lambda p: p.select, obj.data.polygons)) selected_polygons = [p for p in obj.data.polygons if p.select] if len(selected_polygons): p = selected_polygons[0] r = g = b = 0 for i in p.loop_indices: c = colors[i].color r += c[0] g += c[1] b += c[2] r /= p.loop_total g /= p.loop_total b /= p.loop_total target = Color((r, g, b)) for p in obj.data.polygons: r = g = b = 0 for i in p.loop_indices: c = colors[i].color r += c[0] g += c[1] b += c[2] r /= p.loop_total g /= p.loop_total b /= p.loop_total source = Color((r, g, b)) print(target, source) if (abs(source.r - target.r) < threshold and abs(source.g - target.g) < threshold and abs(source.b - target.b) < threshold): p.select = True bpy.ops.object.mode_set(mode="EDIT")
def createOneFrame(self, f): if self.attach: self.createVoxel(self.size, Color()) real = bpy.context.object real.name = self.obj.name + '_Voxels_Frame_' + str(f) real.location = self.obj.location bpy.ops.object.editmode_toggle() bpy.ops.mesh.delete(type='VERT') bpy.ops.object.editmode_toggle() self.doVoxel(bpy.context.scene) if self.attach: for o in bpy.data.objects: o.select_set(False) for color_str in self.cubes_map: for c in self.cubes_map[color_str]: c.select_set(True) real.select_set(True) bpy.context.view_layer.objects.active = real bpy.ops.object.join() if self.bool_voxel_animation: self.addHideShowKey(real, f) self.cubes_map = {}
def get_vcolors(self, context, obj, n): vcolor_dict = defaultdict(list) mesh = obj.data color_layer = obj.data.vertex_colors[0] i = 0 for poly in mesh.polygons: for idx in poly.loop_indices: loop = mesh.loops[idx] color = color_layer.data[i].color vcolor_dict[loop.vertex_index].append(color) i += 1 avg_vcolors = {} for v in vcolor_dict: avg_vcolors[v] = Color( (sum([c.r for c in vcolor_dict[v]]) / len(vcolor_dict[v]), sum([c.g for c in vcolor_dict[v]]) / len(vcolor_dict[v]), sum([c.b for c in vcolor_dict[v]]) / len(vcolor_dict[v]))) # Sort verts by value verts_sorted_by_value = sort_by_value(avg_vcolors, [], 1) start = len(avg_vcolors) - n culled_vert_list = verts_sorted_by_value[start:] vcolors = {v: avg_vcolors[v] for v in culled_vert_list} return vcolors
def draw_common_buttons(self, context, layout): layout.prop(self, "priority") emission_socket = self.inputs["Emission"] if emission_socket.is_linked or emission_socket.default_value != Color( (0.0, 0.0, 0.0)): lightgroups = context.scene.luxcore.lightgroups layout.prop_search(self, "lightgroup", lightgroups, "custom", icon=icons.LIGHTGROUP, text="") layout.prop(self, "color_depth") # Warn the user if he tries to use a 2D texture in a volume because it doesn't work has_2D_input = False for socket in self.inputs: node = utils_node.get_linked_node(socket) if node and "2D Mapping" in node.inputs: has_2D_input = True break if has_2D_input: layout.label(text="Can't use 2D textures!", icon=icons.WARNING)
def weight2vert_col(color): obj = bpy.context.active_object obj_data = obj.data vert_groups = obj.vertex_groups col = Color() for vert_g in vert_groups: group_name = vert_g.name #check for existing group with the same name if None == obj_data.vertex_colors.get(group_name): obj_data.vertex_colors.new(name=group_name) color_map = obj_data.vertex_colors[group_name] for poly in obj_data.polygons: for loop_ind in poly.loop_indices: vert_ind = obj_data.loops[loop_ind].vertex_index #check if the vertex belong to the group weight = 0 for g in obj_data.vertices[vert_ind].groups: if g.group == vert_groups[group_name].index: weight = vert_groups[group_name].weight(vert_ind) #convert weight to vert_col if color == 'BW': col = convert(weight, 'W2BW') else: col = convert(weight, 'W2HSV') #assign to the color map color_map.data[loop_ind].color = col
def execute(self, context): from zlib import crc32 objects = context.selected_objects if not objects: self.report({'ERROR'}, 'No objects selected') return {'CANCELLED'} seed = self.seed power = self.power materials = set() for obj in objects: for slot in obj.material_slots: materials.add(slot.material) for mat in materials: data = bytearray(mat.name, 'utf8') data.append(seed) hsh = crc32(data) color = Color() color.hsv = ((hsh & 0xFF) / 0xFF, (((hsh >> 8) & 3) / 3 * 0.5 + 0.5) * power, ((hsh >> 2) & 1) * (0.5 * power) + 0.5) color = [color.r, color.g, color.b] if IS_28: color.append(1.0) # alpha mat.diffuse_color = color return {'FINISHED'}
def create_vertex_color_map(): # Find upper and lower z values. # there are many ways to skin this cat, but i'm going to be lazy z_list = [] for i in bpy.context.active_object.data.vertices: z_list.append(i.co.z) z_list = sorted(z_list) lower_old = z_list[0] upper_old = z_list[len(z_list) - 1] lower_new = 0.0 upper_new = 1.0 my_object = bpy.context.active_object.data vert_list = my_object.vertices color_map = my_object.vertex_colors.new() i = 0 for poly in my_object.polygons: for idx in poly.loop_indices: loop = my_object.loops[idx] v = loop.vertex_index zheight = vert_list[v].co.z remap_1 = remap(zheight, lower_old, upper_old, lower_new, upper_new) color_map.data[i].color = Color((remap_1, remap_1, remap_1)) i += 1
def RunCombineAO(context): obj = bpy.context.active_object mesh = obj.data # Set mode oldMode = bpy.context.object.mode if (bpy.context.mode != 'OBJECT'): bpy.ops.object.mode_set(mode='OBJECT') # Check layers exist CheckVertexColorLayer(context.scene.scn_inputVCLayer1, mesh) CheckVertexColorLayer(context.scene.scn_inputVCLayer2, mesh) CheckVertexColorLayer(context.scene.scn_targetVCLayer, mesh) # Get layers inputLayer1 = mesh.vertex_colors[context.scene.scn_inputVCLayer1] inputLayer2 = mesh.vertex_colors[context.scene.scn_inputVCLayer2] targetLayer = mesh.vertex_colors[context.scene.scn_targetVCLayer] color = Color() # Perform operation i = 0 for poly in mesh.polygons: for loop in poly.loop_indices: color.r = inputLayer1.data[i].color.r * inputLayer2.data[i].color.r color.g = inputLayer1.data[i].color.g * inputLayer2.data[i].color.g color.b = inputLayer1.data[i].color.b * inputLayer2.data[i].color.b targetLayer.data[loop].color = color i += 1 # Update mesh and revert to old mode mesh.update() bpy.ops.object.mode_set(mode=oldMode) print("Finished CombineAOOperator")
def to_node_color(color, from_linear=False): """Gets color ready for assigning to Blender nodes. 1. Sets minimal HSV value attribute for rendering 2. Applies pre gamma correction 3. Returns it as tuple of 4 floats RGBA :param color: color to be converted for usage in node :type color: mathutils.Color | collections.Iterable[float] :param from_linear: should color first be converted from linear space? :type from_linear: bool :return: RGBA as tuple of floats :rtype: tuple[float] """ srgb_color = color if from_linear: srgb_color = linear_to_srgb(color) c = Color( srgb_color[:3] ) # copy color so changes won't reflect on original passed color object c = pre_gamma_corrected_col(c) # set minimal value for Blender to use it in rendering if c.v == 0: c.v = 0.000001 # this is the smallest value Blender still uses for rendering return tuple(c) + (1, )
def timing_input_start(self, context): # standardise framerange display bpy.ops.time.view_all() # calculate margin and pixel per frame self._margin = ceil(context.region.width * 0.01) self._ppf = (context.region.width - self._margin * 2) / ( context.scene.frame_end - context.scene.frame_start) # draw existing timeline marker in a less prominent colour self._marker_color_old = context.user_preferences.themes[ 0].timeline.frame_current.copy() context.user_preferences.themes[0].timeline.frame_current = Color( (0.5, 0.5, 0.5)) # deactivate frame indicator self._show_frame_indicator = context.space_data.show_frame_indicator context.space_data.show_frame_indicator = False # register draw handle self._draw_handle = context.region.callback_add( draw_callback, (self, context), 'POST_PIXEL') PerformTimeOperator.timing_input_start(self, context)
def transfer_weight_to_vertex_color(self, obj): col = Color() col.r, col.g, col.b = 1, 1, 1 col.h, col.s, col.v = 0, 1, 1 for poly in obj.data.polygons: for loop in poly.loop_indices: weight = 0 vertindex = obj.data.loops[loop].vertex_index try: weight = obj.vertex_groups.active.weight(vertindex) if self.colored: col.h, col.s, col.v = 0.6666 * weight, 1, 1 else: col.r = col.g = col.b = weight except: if self.colored: col.r, col.g, col.b = 1, 1, 1 col.h, col.s, col.v = 0.666, 1, 1 else: col.h, col.s, col.v = 0, 1, 1 col.r, col.g, col.b = 0, 0, 0 obj.data.vertex_colors.active.data[loop].color = (col.b, col.g, col.r, 1)
def set_diffuse(node_tree, color): """Set diffuse color to shader. :param node_tree: node tree of current shader :type node_tree: bpy.types.NodeTree :param color: diffuse color :type color: Color or tuple """ hsv_col = Color(color[:3]) # force diffuse color to be rendered so ambient color can be simulated! if hsv_col.v == 0: hsv_col.v = 0.000001 # this is the smallest value Blender still uses for rendering color = tuple(hsv_col) + (1, ) node_tree.nodes[ Glass.DIFF_COL_NODE].outputs['Color'].default_value = color node_tree.nodes[ Glass.OUT_MAT_NODE].material.diffuse_intensity = hsv_col.v * 0.7 # fix emit color representing ambient. # NOTE: because emit works upon diffuse light we need to fake factors if diffuse drops ambient = node_tree.nodes[ Glass.OUT_MAT_NODE].material.scs_props.shader_attribute_add_ambient node_tree.nodes[Glass.OUT_MAT_NODE].material.emit = (ambient / 10) * ( 1 / hsv_col.v)
def brick_colour(self, brick_size, brick_name): height = brick_size[2] width = brick_size[0] depth = brick_size[1] if brick_name in bpy.data.materials: mat = bpy.data.materials[brick_name] else: colour = self.base_colours[depth] if height == 1: colour = [colour[0], colour[1] - 0.2, colour[2]] if width == 2: colour = [colour[0] + 0.028, colour[1], colour[2]] c = Color() c.hsv = colour[0], colour[1], colour[2] mat_name_string = brick_name mat = bpy.data.materials.new(name=mat_name_string) mat.diffuse_color = c return mat
def invoke(self, context, event): if context.area.type == 'VIEW_3D': if not context.active_object: self.report({'WARNING'}, "Nothing to time") return {'CANCELLED'} self.props = context.window_manager.sketch_time # source path global g_src_path if g_src_path: g_src_path.draw_end(context) src_path_props = self.props.path src_path_props.color = Color((0.7, 0.7, 0.7)) src_path_props.features_shape = 'cross' self._source_path = MotionPath(src_path_props) self._source_path._is_2d = True self._source_path.draw_begin(context) ret_val = PerformTimeOperator.invoke(self, context, event) # target path global g_tgt_path g_tgt_path = self._target_path if not g_tgt_path.visible: g_tgt_path.draw_begin(context) return ret_val else: self.report({'WARNING'}, "View3D not found, cannot run SketchTime") return {'CANCELLED'}
def avg_col(cols): avg_col = Color((0.0, 0.0, 0.0)) for col in cols: avg_col[0] += col[0] / len(cols) avg_col[1] += col[1] / len(cols) avg_col[2] += col[2] / len(cols) return avg_col
def setup_materials(materials_array, materials): if materials is not None: material_count = len(set(materials.values())) c = Color() for i in range(material_count): c.hsv = (i / float(material_count), 0.7, 0.25) materials_array.append(make_material("CelticKnot", c))
def _add_point_from_nvm_entry(point_cloud: PointCloud, args: List[str]) -> None: """Set a point of the cloud given the list of strings from the NVM file entry. Adds the point to the point cloud. Arguments: args {List[str]} -- List[<XYZ> <RBG> <number of measurements> List[<image index> <feature Index> <xy>]] Raises: RuntimeError: if called when trying to set more points than the cloud size """ assert len(args) >= 7 and (len(args) == (7 + 4 * int(args[6]))) # load vertex coordinates position = ReconstructionNvm.NVM_TO_BLENDER @ Vector( map(float, args[0:3])) # # load colors color = Color(map(int, args[3:6])) / 255. # # load measures # self.number_of_measures = int(args[6]) # self.measures = [] # for offset in range(self.number_of_measures): # start_index = 7 + offset*4 # self.measures.append(ReconMeasure(args[start_index:start_index+4])) # point_cloud.add_point(position, color)
def toggle_grayscale(self, context): brush = context.tool_settings.vertex_paint.brush if self.use_grayscale: self.brush_color = brush.color self.brush_secondary_color = brush.secondary_color v1 = self.brush_value_isolate v2 = self.brush_secondary_value_isolate brush.color = Color((v1, v1, v1)) brush.secondary_color = Color((v2, v2, v2)) else: brush.color = self.brush_color brush.secondary_color = self.brush_secondary_color return None
def __update_text(self, props): if not "Temperature_Text" in bpy.data.objects: bpy.ops.object.text_add() bpy.context.active_object.name = "Temperature_Text" text_obj = bpy.data.objects["Temperature_Text"] if text_obj.type == 'FONT': text_obj.data.body = "{0:.1f}".format(props.temperature) # make material slot if len(text_obj.material_slots) == 0: bpy.context.scene.objects.active = text_obj bpy.ops.object.material_slot_add() text_obj.material_slots[0].material = bpy.data.materials['Material'] mtrl = text_obj.material_slots[0].material # change color min_temp = -10 max_temp = 50 temp_range = max_temp - min_temp color = Color() color.hsv = ( 1.0 - (((props.temperature-min_temp)/(temp_range-10))*270+90)/360, 0.95, 1.0 ) mtrl.diffuse_color = color
def vectorToColor(self, v, scale): print ("Encoding: x:%2.2f, y:%2.2f, z:%2.2f" % (v.x, v.y, v.z)) # Convert vector v to a color of rgb using scale # Axis flipping here is annoying, basically we're swapping default # blender axis for default unity axis if scale.x == 0: xscale = 0 else: xscale = 1.0 / scale.x if scale.z == 0: yscale = 0 else: yscale = 1.0 / scale.z if scale.y == 0: zscale = 0 else: zscale = 1.0 / scale.y out = Vector((((v.x * xscale) + 1.0) / 2.0, ((v.y * yscale) + 1.0) / 2.0, ((v.z * zscale) + 1.0) / 2.0)) print ("Color will be: r:%2.2f, g:%2.2f, b:%2.2f" % (out.x, out.z, out.y)) # FIXME: This must support the selected "direction" UP and FORWARD # Right now we're just swapping y and z ( x*-1 forward) return Color((out.x, out.z, out.y))
def convert_to_color_group(obj, name): """ Convert a Weight vertex group to color """ if name in obj.data.vertex_colors: group = obj.data.vertex_colors[name] else: group = obj.data.vertex_colors.new(name=name) source = obj.vertex_groups[name] polygons = obj.data.polygons inner_loop_index = 0 for face in polygons: vertex_index = 0 for index in face.loop_indices: weight = source.weight(face.vertices[vertex_index]) vcolor = Color((weight, weight, weight)) group.data[inner_loop_index].color = vcolor inner_loop_index += 1 vertex_index += 1
def draw_common_buttons(self, context, layout): layout.prop(self, "priority") emission_socket = self.inputs["Emission"] if emission_socket.is_linked or emission_socket.default_value != Color((0.0, 0.0, 0.0)): lightgroups = context.scene.luxcore.lightgroups layout.prop_search(self, "lightgroup", lightgroups, "custom", icon=icons.LIGHTGROUP, text="") layout.prop(self, "color_depth") # Warn the user if he tries to use e.g. a 2D texture in a volume because it doesn't work def get_incompatible_inputs(node): if node.bl_idname in self.INCOMPATIBLE_TEXTURE_NODES: return node.name for socket in node.inputs: next_node = utils_node.get_linked_node(socket) if next_node: name = get_incompatible_inputs(next_node) if name: return name return None incompatible_input = get_incompatible_inputs(self) if incompatible_input: col = layout.column() col.label(text="Incompatible texture!", icon=icons.WARNING) col.label(text=f"({incompatible_input})", icon=icons.WARNING)
def __update_suzanne(self, props): # make object if not "Temperature_Suzanne" in bpy.data.objects: bpy.ops.mesh.primitive_monkey_add() bpy.context.active_object.name = "Temperature_Suzanne" suzanne_obj = bpy.data.objects["Temperature_Suzanne"] # make material if len(bpy.data.materials) == 0: bpy.ops.material.new() # make material slot if len(suzanne_obj.material_slots) == 0: bpy.context.scene.objects.active = suzanne_obj bpy.ops.object.material_slot_add() suzanne_obj.material_slots[0].material = bpy.data.materials['Material'] mtrl = suzanne_obj.material_slots[0].material # change color min_temp = -10 max_temp = 50 temp_range = max_temp - min_temp color = Color() color.hsv = ( 1.0 - (((props.temperature-min_temp)/(temp_range-10))*270+90)/360, 0.95, 0.85 ) mtrl.diffuse_color = color
def applyColoringForMeshErrors(context, error_mesh, error_values, *, A = None, B = None, v_group_name = "lap_errors", use_weights=False, normalize_weights=True, use_histogram_preprocess=False, percent_min=0.1, percent_max=0.9): if(use_histogram_preprocess): min_, max_ = getMinMax(error_values, percent_begin=percent_min, percent_end=percent_max); # error_values[np.where(error_values > max_)] = min_; error_values = np.clip(error_values, min_, max_); final_colors, final_weights = getInterpolatedColorValues(error_values, A, B, normalize=normalize_weights); colors = {}; weights = {}; iterator_model = []; for_vertices = not (len(error_values) == len(error_mesh.data.polygons)); if(for_vertices): iterator_model = error_mesh.data.vertices; else: iterator_model = error_mesh.data.polygons; for it_elem in iterator_model: try: (r,g,b,a) = final_colors[it_elem.index]; except ValueError: (r,g,b) = final_colors[it_elem.index]; color = Color((r,g,b)); colors[it_elem.index] = color; weights[it_elem.index] = final_weights[it_elem.index]; if(for_vertices and use_weights): applyVertexWeights(context, error_mesh, weights, v_group_name = v_group_name); applyVertexColors(context, error_mesh, colors, v_group_name=v_group_name, for_vertices=for_vertices);
def get_color_id(index, count, jitter=False): # Get unique color color = Color() indexList = [ 0, 171, 64, 213, 32, 96, 160, 224, 16, 48, 80, 112, 144, 176, 208, 240, 8, 24, 40, 56, 72, 88, 104, 120, 136, 152, 168, 184, 200, 216, 232, 248, 4, 12, 20, 28, 36, 44, 52, 60, 68, 76, 84, 92, 100, 108, 116, 124, 132, 140, 148, 156, 164, 172, 180, 188, 196, 204, 212, 220, 228, 236, 244, 252, 2, 6, 10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 102, 106, 110, 114, 118, 122, 126, 130, 134, 138, 142, 146, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113, 115, 117, 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139, 141, 143, 145, 147, 149, 151, 153, 155, 157, 159, 161, 163, 165, 167, 169, 128, 173, 175, 177, 179, 181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201, 203, 205, 207, 209, 211, 192, 215, 217, 219, 221, 223, 225, 227, 229, 231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255 ] i = 0 if index > 255: while index > 255: index -= 256 i += 1 if jitter: color.hsv = ((indexList[index] + 1 / (2**i)) / 256), 0.9, 1.0 else: color.hsv = (index / (count)), 0.9, 1.0 return color