How can I set and get the vertex color property?

Question

I can't find a way to display RGB values (or equivalent) without using the python shell.

I would like to get and set color values numerically (ie. not painting), I can't find it for weight painting either (I expected it to appear in the "n" panel with something like "vertex" as a title).

Answer 1

I would like to get and set color values numerically (ie. not painting),

There may be add-ons that cater to this, but at present (March 2016)

• Blender doesn't have a (non-Python) way to set the Vertex Colors per selected vertex/vertices. Per face is however, as stated below, not a problem.

• There is no built-in interface (yet) to get the rgb value of a selected Vertex. Each vertex can be shared by a number of faces, therefore a vertex doesn't necessarily have one color associated with it. Behind the scenes the Vertex Colors are not stored in the data per vertex but in a Vertex Color layer, which stores vertex colors for each face of the mesh.

  Possibly this explains that a bit more clear. There are 9 verts in this subdivided plane, and the middle vertex is used in 4 faces and therefore has 4 different colors associated.

Vertex Color Map

You can set a collection of faces to one colour in vertex paint mode, by selecting them and setting the colour from the colour picker, then shift+K (while the mouse cursor is inside the viewport) will fill the selection with that colour. You can enter numericals into the Blender colour picker.

You can pick faces with face selection masking

If you want to do it by script:

import bpy
import random
 
# start in object mode
obj = bpy.data.objects["Cube"]
mesh = obj.data

if not mesh.vertex_colors:
    mesh.vertex_colors.new()

"""
let us assume for sake of brevity that there is now 
a vertex color map called  'Col'    
"""

color_layer = mesh.vertex_colors["Col"]

# or you could avoid using the color_layer name
# color_layer = mesh.vertex_colors.active  

i = 0
for poly in mesh.polygons:
    for idx in poly.loop_indices:
        r, g, b = [random.random() for i in range(3)]
        color_layer.data[i].color = (r, g, b, 1.0)
        i += 1

# set to vertex paint mode to see the result
bpy.ops.object.mode_set(mode='VERTEX_PAINT')

Also a small blogpost about vertex colours here and here, if you are so inclined.

For Weight Painting, i'm not sure -- i'll let someone more familiar with that give an answer

Answer 2

You can try this code to apply color to vertices selected in edit mode:

import bpy

def color_to_vertices(color):
    mesh = bpy.context.active_object.data
    bpy.ops.object.mode_set(mode = 'VERTEX_PAINT')

    selected_verts = []
    for vert in mesh.vertices:
        if vert.select == True:
            selected_verts.append(vert)

    for polygon in mesh.polygons:
        for selected_vert in selected_verts:
            for i, index in enumerate(polygon.vertices):
                if selected_vert.index == index:
                    loop_index = polygon.loop_indices[i]
                    mesh.vertex_colors.active.data[loop_index].color = color

    bpy.ops.object.mode_set(mode = 'EDIT')

import random

RGB = [random.uniform(0,1) for i in range(3)]
color_to_vertices(RGB)

The result will be like this:

Don't forget about proper material node setup if you want to see the result in edit mode (material viewport shading) and render:

For convenience sake you maybe want to create some panel and an operator.

Answer 3

If you happen to be working with .ply files (or can convert your model to that), I recommend using the Point Cloud Visualizer, like so:

from space_view3d_point_cloud_visualizer import PlyPointCloudReader

ply_filename = "some_file.ply"
point_cloud = PlyPointCloudReader(ply_filename).points

# get color of point at index 100
red = point_cloud['red'][100]
blue = point_cloud['blue'][100]
green = point_cloud['green'][100]

Answer 4

Update for 4.0 and the new Attribute API.

IN OBJECT MODE

import bpy
import random

obj = bpy.context.active_object
if obj.type == 'MESH':
    mesh = obj.data

    point_color_attribute = mesh.color_attributes.get("MyPointColors") or mesh.color_attributes.new(name="MyPointColors", type="BYTE_COLOR", domain="POINT")
    point_colors = [None] * len(mesh.vertices) * 4
    point_color_attribute.data.foreach_get("color_srgb", point_colors)  # Get Point Colors
    print(point_colors)

    for _ in range(len(mesh.vertices)):
        point_colors.extend((random.random(), random.random(), random.random(), 1))
    point_color_attribute.data.foreach_set("color_srgb", point_colors)  # Set Point Colors
    print(point_colors)

    corner_color_attribute = mesh.color_attributes.get("MyCornerColors") or mesh.color_attributes.new(name="MyCornerColors", type="BYTE_COLOR", domain="CORNER")
    corner_colors = [None] * len(mesh.loops) * 4
    point_color_attribute.data.foreach_get("color_srgb", corner_colors)  # Get Corner Colors
    print(corner_colors)

    for _ in range(len(mesh.loops)):
        corner_colors.extend((random.random(), random.random(), random.random(), 1))
    corner_color_attribute.data.foreach_set("color_srgb", corner_colors)  # Set Corner Colors
    print(corner_colors)

IN EDIT MODE

In edit mode the regular way to access attributes yields empty sequences. You have to use the bmesh construct.

import bpy
import bmesh
import random

obj = bpy.context.active_object
if obj.type == 'MESH':
    mesh = obj.data
    bm = bmesh.from_edit_mesh(mesh)

    point_color_attribute = mesh.color_attributes.get("MyPointColors") or mesh.color_attributes.new(name="MyPointColors", type="BYTE_COLOR", domain="POINT")
    point_color_layer = bm.verts.layers.color[point_color_attribute.name]
    point_colors = []
    for vert in bm.verts:
        point_colors.extend(vert[point_color_layer])  # Get Point Colors
    print(point_colors)

    point_colors = []
    for vert in bm.verts:
        vert[point_color_layer] = (random.random(), random.random(), random.random(), 1)  # Set Point Colors

    corner_color_attribute = mesh.color_attributes.get("MyCornerColors") or mesh.color_attributes.new(name="MyCornerColors", type="BYTE_COLOR", domain="CORNER")
    corner_color_layer = bm.loops.layers.color[corner_color_attribute.name]
    corner_colors = []
    for face in bm.faces:
        for loop in face.loops:
            corner_colors.extend(loop[corner_color_layer])  # Get Corner Colors
    print(corner_colors)

    for face in bm.faces:
        for loop in face.loops:
            loop[corner_color_layer] = (random.random(), random.random(), random.random(), 1)  # Set Corner Colors
            
    bmesh.update_edit_mesh(mesh)