visualize_3d Namespace Reference

Functions
def	remove_obj (scene)
def	create_new_material (passedName, passedcolor)
def	def_scene (box_length, res_stand, xres, yres, zres)
def	create_cube (box_length, res_stand, xres, yres, zres, step_size, dens_scale, voxelfile)
def	create_volume (passedName, xres, yres, zres, step_size, dens_scale, voxelfile)
def	createCage (passedName)
def	render_img (filename)
def	add_fiber ()

Variables
string	voxelfile = "test_Edges.bvox"
string	outfile = "image.png"
	infile = open(voxelfile, "r")
int	xDim = 256
def	scene = def_scene(5, xDim, xDim, yDim, zDim)

Function Documentation

add_fiber()

def visualize_3d.add_fiber

(

)

Definition at line 171 of file visualize_3d.py.

References create_new_material().

def add_fiber():
    temp_fiber = bpy.ops.mesh.primitive_cylinder_add(radius = 0.1,
                     rotation=(0, 0, 0))

    ob = bpy.context.active_object
    ob.scale[2] = 5
    ob.name = "fiber"
    me = ob.data
    color = (1, 1, 1)
    mat = create_new_material(ob.name, color)
    me.materials.append(mat)




#------------------------------------------------------------------------------#
# MAIN
#------------------------------------------------------------------------------#

Here is the call graph for this function:

create_cube()

def visualize_3d.create_cube	(		box_length,
			res_stand,
			xres,
			yres,
			zres,
			step_size,
			dens_scale,
			voxelfile
	)

Definition at line 103 of file visualize_3d.py.

References create_volume().

Referenced by def_scene().

                dens_scale, voxelfile):
    cube = bpy.ops.mesh.primitive_cube_add(
               location=(0,0,0),
               radius = box_length * 0.5)

    bpy.ops.object.mode_set(mode="EDIT")
    bpy.ops.object.mode_set(mode="OBJECT")
    ob = bpy.context.object
    ob.scale = ((xres/res_stand, yres/res_stand, zres/res_stand))

    # setting voxel material
    me = ob.data
    mat = create_volume("MaterialVolume", xres, yres, zres, step_size,
                        dens_scale, voxelfile)
    me.materials.append(mat)

    return cube

# function to create voxel material for cube

Here is the call graph for this function:

Here is the caller graph for this function:

create_new_material()

def visualize_3d.create_new_material	(		passedName,
			passedcolor
	)

Definition at line 40 of file visualize_3d.py.

Referenced by add_fiber().

def create_new_material (passedName,passedcolor):
    tempMat = bpy.data.materials.new(passedName)
    if tempMat != None:
        tempMat.diffuse_color = passedcolor
        tempMat.diffuse_shader = 'LAMBERT'
        tempMat.diffuse_intensity = 1.0
        tempMat.specular_color = (0.9,0.9,0.9)
        tempMat.specular_shader = 'COOKTORR'
        tempMat.specular_intensity = 0.5
        tempMat.use_transparency=False
        tempMat.alpha = 0.5
        tempMat.ambient = 0.2
        tempMat.emit = 0.9
        tempMat.keyframe_insert(data_path="diffuse_color", frame=1, index=-1)
    return tempMat

# Function to define the scene

Here is the caller graph for this function:

create_volume()

def visualize_3d.create_volume	(		passedName,
			xres,
			yres,
			zres,
			step_size,
			dens_scale,
			voxelfile
	)

Definition at line 123 of file visualize_3d.py.

Referenced by create_cube().

                  voxelfile):
    volMat = bpy.data.materials.new(passedName)
    volMat.type = "VOLUME"
    volMat.volume.density = 0.0
    volMat.volume.step_method = "CONSTANT"
    volMat.volume.step_size = step_size
    volMat.volume.depth_threshold = 0.01
    volMat.volume.density_scale = dens_scale
    matTex = volMat.texture_slots.add()
    voxTex = bpy.data.textures.new("VoxelData", type = "VOXEL_DATA")
    voxTex.voxel_data.file_format = "BLENDER_VOXEL"
    voxTex.use_color_ramp = True
    voxTex.color_ramp.color_mode = "RGB"
    ramp = voxTex.color_ramp

    values = [(0.0,(0,0,1,0)), (0.5,(0,0,1,0.3)), (0.75,(1,0,1,0.5)), (1.0, (1,0,0,1))]

    for n,value in enumerate(values):
        #ramp.elements.new((n+1)*0.2)
        (pos, color) = value
        ramp.elements.new(pos)
        elt = ramp.elements[n]
        elt.position = pos
        elt.color = color
    voxTex.voxel_data.filepath = voxelfile
    voxTex.voxel_data.resolution = (xres, yres, zres)
    matTex.texture = voxTex
    matTex.use_map_to_bounds = True
    matTex.texture_coords = 'ORCO'
    matTex.use_map_color_diffuse = True 
    matTex.use_map_emission = True 
    matTex.emission_factor = 1
    matTex.emission_color_factor = 1
    matTex.use_map_density = True 
    matTex.density_factor = 1
    return volMat

Here is the caller graph for this function:

createCage()

def visualize_3d.createCage

(

passedName

)

Definition at line 160 of file visualize_3d.py.

def createCage(passedName):
    cageMat = bpy.data.materials.new(passedName)
    cageMat.use_shadeless = True
    return cageMat

# Render Scene into image

def_scene()

def visualize_3d.def_scene	(		box_length,
			res_stand,
			xres,
			yres,
			zres
	)

Definition at line 57 of file visualize_3d.py.

References create_cube(), and remove_obj().

def def_scene(box_length, res_stand, xres, yres, zres):
    # first, we need to relocate the camera
    x_cam = 0.0
    y_cam = 1.2
    z_cam = 0.8

    scene = bpy.context.scene

    # removing unnecessary obects (basically leaving only the camera)
    remove_obj(scene)

    # defining dummy location (empty) to point camera at.
    bpy.ops.object.add(type="EMPTY",
                       location=(0,0,0))

    context = bpy.context

    bpy.ops.object.select_pattern(pattern="Camera")
    bpy.context.scene.objects.active = bpy.context.scene.objects["Camera"]
    ob = bpy.data.objects["Camera"]
    bpy.ops.object.constraint_add(type = "TRACK_TO")
    target = bpy.data.objects.get("Empty", False)
    ob.constraints["Track To"].target=target

    ob.constraints["Track To"].track_axis = "TRACK_NEGATIVE_Z"
    ob.constraints["Track To"].up_axis = "UP_Y"

    scene.camera.location.x = box_length * x_cam * xres / res_stand
    scene.camera.location.y = box_length * y_cam * yres / res_stand
    scene.camera.location.z = box_length * z_cam * zres / res_stand

    # set's FOV
    scene.camera.data.angle = 50*(np.pi/180.0)
    bpy.data.cameras["Camera"].ortho_scale = 21.0

    # Set number of cores used
    scene.render.threads_mode = "FIXED"
    scene.render.threads = 8

    # Sets the BG to be black
    bpy.data.worlds["World"].horizon_color = (1,1,1)

    return scene

# function to create cube for data

Here is the call graph for this function:

remove_obj()

def visualize_3d.remove_obj

(

scene

)

Definition at line 34 of file visualize_3d.py.

Referenced by def_scene().

def remove_obj(scene):
    for ob in scene.objects:
        if ob.name != "Camera":
            scene.objects.unlink(ob)

# Creates sphere material

Here is the caller graph for this function:

render_img()

def visualize_3d.render_img

(

filename

)

Definition at line 166 of file visualize_3d.py.

def render_img(filename):
    bpy.data.scenes['Scene'].render.filepath = filename
    bpy.ops.render.render( write_still=True )

# Function to add fiber

Variable Documentation

infile

visualize_3d.infile = open(voxelfile, "r")

Definition at line 27 of file visualize_3d.py.

outfile

string visualize_3d.outfile = "image.png"

Definition at line 26 of file visualize_3d.py.

scene

def visualize_3d.scene = def_scene(5, xDim, xDim, yDim, zDim)

Definition at line 191 of file visualize_3d.py.

voxelfile

string visualize_3d.voxelfile = "test_Edges.bvox"

Definition at line 25 of file visualize_3d.py.

xDim

int visualize_3d.xDim = 256

Definition at line 190 of file visualize_3d.py.