points = mesh.create_points()
point_selection = mesh.create_point_selection()
Cs = mesh.writable_vertex_data().create_array("Cs", "k3d::color")
width = mesh.writable_vertex_data().create_array("width", "k3d::double_t")
groups = mesh.create_linear_curve_groups()
first_curves = groups.create_first_curves()
curve_counts = groups.create_curve_counts()
periodic_curves = groups.create_periodic_curves()
materials = groups.create_materials()
curve_first_points = groups.create_curve_first_points()
curve_point_counts = groups.create_curve_point_counts()
curve_selection = groups.create_curve_selection()
curve_points = groups.create_curve_points()
positions = [
k3d.point3(-5, 0, -5),
k3d.point3(5, 0, -5),
k3d.point3(-5, 0, 5),
k3d.point3(5, 0, 5)
]
colors = [
k3d.color(1, 0, 0),
k3d.color(0, 1, 0),
k3d.color(0, 0, 1),
k3d.color(1, 1, 1)
]
widths = [0.1, 0.8, 0.8, 0.1]
for position in positions:
points.append(position)
point_selection.append(0.0)
test_ri_texture.name = "test_ri_texture"
test_node = k3d.plugin.create("Axes", document)
test_node.name = "test_node"
create_property(test_container, "k3d::bool_t", True)
create_property(test_container, "k3d::color", k3d.color(1, 2, 3))
create_property(test_container, "k3d::double_t", 3.1415)
create_property(test_container, "k3d::filesystem::path", k3d.filesystem.generic_path("/foo/bar/baz"))
create_property(test_container, "k3d::gl::imesh_painter*", test_gl_mesh_painter)
create_property(test_container, "k3d::imaterial*", test_material)
create_property(test_container, "k3d::inode*", test_node)
create_property(test_container, "k3d::int32_t", 19700827)
create_property(test_container, "k3d::matrix4", k3d.scale3(1, 2, 3))
create_property(test_container, "k3d::normal3", k3d.normal3(1, 2, 3))
create_property(test_container, "k3d::point3", k3d.point3(1, 2, 3))
create_property(test_container, "k3d::point4", k3d.point4(1, 2, 3, 4))
create_property(test_container, "k3d::ri::imesh_painter*", test_ri_mesh_painter)
create_property(test_container, "k3d::ri::itexture*", test_ri_texture)
create_property(test_container, "k3d::string_t", "K-3D Rocks!")
create_property(test_container, "k3d::vector3", k3d.vector3(1, 2, 3))
path = testing.binary_path() + "/document.serialization.properties.output.k3d"
document.save(path)
def test_property(value, expected_value):
if value != expected_value:
raise "property value doesn't match: ", value, expected_value
document2 = k3d.open_document(k3d.filesystem.native_path(path))
test_container2 = k3d.node.lookup_one(document, "test_container")
context.document.start_change_set()
try:
floor = context.document.new_node("PolyCube")
floor.name = "Floor"
floor.width = 10
floor.height = 10
floor.depth = 2
floor_instance = context.document.new_node("MeshInstance")
floor_instance.name = "Floor Instance"
floor_instance.gl_painter = k3d.node.lookup_one(context.document, "GL Default Painter")
floor_instance.ri_painter = k3d.node.lookup_one(context.document, "RenderMan Default Painter")
k3d.property.connect(context.document, floor.get_property("output_mesh"), floor_instance.get_property("input_mesh"))
k3d.dynamic_cast(floor_instance, "isnappable").add_snap_target("-x", k3d.point3(-5, 0, 0))
k3d.dynamic_cast(floor_instance, "isnappable").add_snap_target("+x", k3d.point3(5, 0, 0))
k3d.dynamic_cast(floor_instance, "isnappable").add_snap_target("-y", k3d.point3(0, -5, 0))
k3d.dynamic_cast(floor_instance, "isnappable").add_snap_target("+y", k3d.point3(0, 5, 0))
k3d.dynamic_cast(floor_instance, "isnappable").add_snap_target("-z", k3d.point3(0, 0, -1))
k3d.dynamic_cast(floor_instance, "isnappable").add_snap_target("+z", k3d.point3(0, 0, 1))
chair = context.document.new_node("PolyCube")
chair.name = "Chair"
chair_instance = context.document.new_node("MeshInstance")
chair_instance.name = "Chair Instance"
chair_instance.gl_painter = k3d.node.lookup_one(context.document, "GL Default Painter")
chair_instance.ri_painter = k3d.node.lookup_one(context.document, "RenderMan Default Painter")
k3d.property.connect(context.document, chair.get_property("output_mesh"), chair_instance.get_property("input_mesh"))
import k3d
import testing
setup = testing.setup_mesh_modifier_test("FrozenMesh", "TriangulateFaces")
mesh = setup.source.create_mesh()
points = mesh.create_points()
point_selection = mesh.create_point_selection()
polyhedron = k3d.polyhedron.create(mesh)
Cs = polyhedron.vertex_attributes().create("Cs", "k3d::color")
positions = [(0, 0, 1), (1, 0, 1), (2, 0, 0), (2, 0, 1), (1, 0, 0), (0, 0, 0)]
for position in positions:
points.append(k3d.point3(position[0], position[1], position[2]))
point_selection.append(0)
polyhedron.shell_types().append(k3d.polyhedron.shell_type.POLYGONS)
polyhedron.face_shells().append(0)
polyhedron.face_first_loops().append(len(polyhedron.loop_first_edges()))
polyhedron.face_loop_counts().append(1)
polyhedron.face_materials().append(None)
polyhedron.face_selections().append(0)
polyhedron.loop_first_edges().append(len(polyhedron.clockwise_edges()))
polyhedron.clockwise_edges().append(1)
polyhedron.edge_selections().append(0)
polyhedron.vertex_points().append(0)
#python
import k3d
document = k3d.new_document()
pointToVector = k3d.plugin.create("PointToVector", document)
vector = k3d.vector3(1, 2, 3)
point = k3d.point3(1, 2, 3)
pointToVector.point = point
if pointToVector.vector != vector:
raise Exception("Incorrect convertion: pointToVector.vector = " + str(pointToVector.vector)
+ "; point = " + str(point))
first_primitives = blobbies.create_first_primitives()
primitive_counts = blobbies.create_primitive_counts()
first_operators = blobbies.create_first_operators()
operator_counts = blobbies.create_operator_counts()
materials = blobbies.create_materials()
primitives = blobbies.create_primitives()
primitive_first_floats = blobbies.create_primitive_first_floats()
primitive_float_counts = blobbies.create_primitive_float_counts()
floats = blobbies.create_floats()
Cs = blobbies.writable_varying_data().create_array("Cs", "k3d::color")
operators = blobbies.create_operators()
operator_first_operands = blobbies.create_operator_first_operands()
operator_operand_counts = blobbies.create_operator_operand_counts()
operands = blobbies.create_operands()
ellipsoids = [k3d.point3(-1, 0, 1), k3d.point3(1, 0, 1), k3d.point3(1, 0, -1), k3d.point3(-1, 0, -1)]
first_primitives.append(len(primitives))
primitive_counts.append(len(ellipsoids) + 1)
first_operators.append(len(operators))
operator_counts.append(1)
materials.append(k3d.dynamic_cast(Document.get_node("Material"), "imaterial"))
for center in ellipsoids:
primitives.append(k3d.primitive_type.ellipsoid)
primitive_first_floats.append(len(floats))
primitive_float_counts.append(16)
for i in (k3d.translate3(center) * k3d.scale3(1, 1, 1)).column_major_list():
floats.append(i)
primitives.append(k3d.primitive_type.segment)
# python
from math import radians
import k3d
k3d.check_node_environment(context, "MeshSourceScript")
# Construct a sphere mesh primitive ...
hyperboloid = k3d.hyperboloid.create(context.output)
color = hyperboloid.parameter_attributes().create("Cs", "k3d::color")
# Add two hyperboloids ...
hyperboloid.matrices().append(k3d.translate3(k3d.vector3(-5, 0, 0)))
hyperboloid.materials().append(None)
hyperboloid.start_points().append(k3d.point3(-2, 2, 2))
hyperboloid.end_points().append(k3d.point3(2, 2, -2))
hyperboloid.sweep_angles().append(radians(360))
hyperboloid.selections().append(0)
color.append(k3d.color(1, 0, 0))
color.append(k3d.color(1, 0, 0))
color.append(k3d.color(1, 1, 0))
color.append(k3d.color(1, 1, 0))
hyperboloid.matrices().append(k3d.translate3(k3d.vector3(5, 0, 0)))
hyperboloid.materials().append(None)
hyperboloid.start_points().append(k3d.point3(-2, 2, 2))
hyperboloid.end_points().append(k3d.point3(2, 2, -2))
hyperboloid.sweep_angles().append(radians(360))
hyperboloid.selections().append(0)
color.append(k3d.color(1, 0, 0))
#python
import k3d
k3d.check_node_environment(locals(), "MeshSourceScript")
# Create two triangles, arranged to form a square ...
vertices = [
k3d.point3(-3, -3, 0),
k3d.point3(3, -3, 0),
k3d.point3(3, 3, 0),
k3d.point3(-3, 3, 0)
]
vertex_counts = [3, 3]
vertex_indices = [0, 1, 3, 1, 2, 3]
material = None
polyhedron = k3d.polyhedron.create(Output, vertices, vertex_counts,
vertex_indices, material)
frozen_mesh = k3d.plugin.create("FrozenMesh", context.document)
frozen_mesh.name = function
# Create a mesh ...
mesh = frozen_mesh.create_mesh()
# Add geometric points to the mesh ...
points = mesh.create_points()
point_selection = mesh.create_point_selection()
for xi in range(0, xcount):
for yi in range(0, ycount):
x = mix(x1, x2, float(xi) / (xcount - 1))
y = mix(y1, y2, float(yi) / (ycount - 1))
z = eval(function)
points.append(k3d.point3(x, y, z))
point_selection.append(0.0)
# Create a particle primitive ...
particles = k3d.particle.create(mesh)
# Create a custom attribute array to control the widths of particles ...
constantwidth = particles.constant_attributes().create("constantwidth", "k3d::double_t")
particles.material().append(None)
constantwidth.append(0.2)
for i in range(len(points)):
particles.points().append(i)
# Connect the FrozenMesh to a MeshInstance to place it in the scene ...
points = mesh.create_points()
point_selection = mesh.create_point_selection()
point_groups = mesh.create_point_groups()
first_points = point_groups.create_first_points()
point_counts = point_groups.create_point_counts()
materials = point_groups.create_materials()
constantwidth = point_groups.writable_constant_data().create_array("constantwidth", "k3d::double_t")
group_points = point_groups.create_points()
for xi in range(0, xcount):
for yi in range(0, ycount):
x = mix(x1, x2, float(xi) / (xcount - 1))
y = mix(y1, y2, float(yi) / (ycount - 1))
z = eval(function)
point = k3d.point3(x, y, z)
points.append(point)
point_selection.append(0.0)
first_points.append(len(group_points))
point_counts.append(len(points))
materials.append(None)
constantwidth.append(0.2)
for i in range(len(points)):
group_points.append(i)
mesh_instance = doc.new_node("MeshInstance")
mesh_instance.name = function + " Instance"
mesh_instance.gl_painter = doc.get_node("GL Default Painter")
mesh_instance.ri_painter = doc.get_node("RenderMan Default Painter")
#python
import k3d
doc = Document
doc.start_change_set()
try:
frozen_mesh = doc.new_node("FrozenMesh")
frozen_mesh.name = "Simple Polyhedron"
mesh = k3d.dynamic_cast(frozen_mesh, "imesh_storage").reset_mesh()
vertices = [k3d.point3(-3, -3, 0), k3d.point3(3, -3, 0), k3d.point3(3, 3, 0), k3d.point3(-3, 3, 0)]
vertex_counts = [3, 3]
vertex_indices = [0, 1, 3, 1, 2, 3]
material = None
polyhedron = k3d.polyhedron.create(mesh, vertices, vertex_counts, vertex_indices, material)
mesh_instance = doc.new_node("MeshInstance")
mesh_instance.name = "Simple Polyhedron Instance"
mesh_instance.gl_painter = doc.get_node("GL Default Painter")
mesh_instance.ri_painter = doc.get_node("RenderMan Default Painter")
doc.set_dependency(mesh_instance.get_property("input_mesh"), frozen_mesh.get_property("output_mesh"))
doc.finish_change_set("Create Simple Polyhedron")
except:
doc.cancel_change_set()
raise
#python
import k3d
import testing
doc = k3d.new_document()
source = k3d.plugin.create("PolyGrid", doc)
centroid = k3d.plugin.create("PointsCentroid", doc)
source.rows = 1
source.columns = 1
selection = k3d.geometry.selection.create(0)
point_selection = k3d.geometry.point_selection.create(selection)
k3d.geometry.point_selection.append(point_selection, 0, 2, 1)
centroid.mesh_selection = selection
k3d.property.connect(doc, source.get_property("output_mesh"), centroid.get_property("input_mesh"))
if centroid.centroid != k3d.point3(0, 5, 0):
raise "unexpected output_vector: " + str(centroid.centroid)
import k3d
context.document.start_change_set()
try:
# Create a FrozenMesh node to act as a mesh source ...
frozen_mesh = k3d.plugin.create("FrozenMesh", context.document)
frozen_mesh.name = "Cubic Curve"
# Create a mesh ...
mesh = frozen_mesh.create_mesh()
# Add geometric points to the mesh ...
points = mesh.create_points()
point_selection = mesh.create_point_selection()
positions = [k3d.point3(-5, 0, -5), k3d.point3(5, 0, -5), k3d.point3(-5, 0, 5), k3d.point3(5, 0, 5)]
for position in positions:
points.append(position)
point_selection.append(0.0)
# Create a cubic curve primitive ...
curves = k3d.cubic_curve.create(mesh)
# Create a custom attribute array to control the width of the curve ...
width = curves.constant_attributes().create("constantwidth", "k3d::double_t")
# Create a custom attribute array to store color values at each curve vertex ...
Cs = curves.vertex_attributes().create("Cs", "k3d::color")
# Add a single curve to the primitive ...
curves.periodic().append(False)
try:
# Create a FrozenMesh node to act as a mesh source ...
frozen_mesh = k3d.plugin.create("FrozenMesh", context.document)
frozen_mesh.name = "Particles"
# Create a mesh ...
mesh = frozen_mesh.create_mesh()
particle_count = 100
size = 10
# Add geometric points to the mesh ...
points = mesh.create_points()
point_selection = mesh.create_point_selection()
for i in range(particle_count):
points.append(k3d.point3(uniform(-size, size), uniform(-size, size), uniform(-size, size)))
point_selection.append(0.0)
# Create a particle primitive ...
particles = k3d.particle.create(mesh)
# Create a custom attribute array to control the widths of particles ...
constantwidth = particles.constant_attributes().create("constantwidth", "k3d::double_t")
# Create a custom attribute array to store color values for each particle ...
Cs = particles.vertex_attributes().create("Cs", "k3d::color")
# Add particles to the primitive ...
particles.material().append(None)
for i in range(particle_count):
particles.points().append(i)
#python import k3d k3d.check_node_environment(context, "MeshSourceScript") # Create two triangles, arranged to form a square ... vertices = [k3d.point3(-3, -3, 0), k3d.point3(3, -3, 0), k3d.point3(3, 3, 0), k3d.point3(-3, 3, 0)] vertex_counts = [3, 3] vertex_indices = [0, 1, 3, 1, 2, 3] material = None polyhedron = k3d.polyhedron.create(context.output, vertices, vertex_counts, vertex_indices, material)
#python
import k3d
import testing
document = k3d.new_document()
instance = k3d.plugin.create("MeshInstance", document)
transform = k3d.plugin.create("FrozenMatrix", document)
transform.matrix = k3d.translate3(1, 0, 0)
k3d.property.connect(document, transform.get_property("output_matrix"),
instance.get_property("input_matrix"))
position = k3d.world_position(instance)
reference = k3d.point3(1, 0, 0)
if position != reference:
raise Exception("Position differs from expected value, expected: " +
str(reference) + ", result: " + str(position))
patches.patch_point_weights().append(0.5) patches.patch_point_weights().append(1) patches.patch_u_knots().append(1) patches.patch_u_knots().append(1) patches.patch_u_knots().append(1) patches.patch_u_knots().append(2) patches.patch_u_knots().append(2) patches.patch_u_knots().append(2) patches.patch_v_knots().append(1) patches.patch_v_knots().append(1) patches.patch_v_knots().append(2) patches.patch_v_knots().append(2) patches.patch_first_trim_loops().append(0) patches.patch_trim_loop_counts().append(0) # Cs.append(k3d.color(1, 0, 0)) # Cs.append(k3d.color(0, 1, 0)) # Cs.append(k3d.color(0, 0, 1)) # Cs.append(k3d.color(1, 1, 1)) positions = [(-5, 5, 5), (5, 5, 5), (5, 5, 10), (-5, -5, 5), (5, -5, 5), (5, -5, 10)] for position in positions: points.append(k3d.point3(position[0], position[1], position[2] + (i * -10))) point_selection.append(0.0)
#python
import k3d
k3d.check_node_environment(locals(), "MeshSourceScript")
blobby = k3d.blobby.create(Output)
Cs = blobby.varying_data().create("Cs", "k3d::color")
# Add four ellipsoids to the blobby ...
ellipsoids = [
k3d.point3(-1, 0, 1),
k3d.point3(1, 0, 1),
k3d.point3(1, 0, -1),
k3d.point3(-1, 0, -1)
]
blobby.first_primitives().append(len(blobby.primitives()))
blobby.primitive_counts().append(len(ellipsoids) + 1)
blobby.first_operators().append(len(blobby.operators()))
blobby.operator_counts().append(1)
blobby.materials().append(Document.get_node("Material"))
for center in ellipsoids:
blobby.primitives().append(k3d.blobby.primitive_type.ELLIPSOID)
blobby.primitive_first_floats().append(len(blobby.floats()))
blobby.primitive_float_counts().append(16)
for i in (k3d.translate3(center[0], center[1], center[2]) *
k3d.scale3(1)).column_major_list():
blobby.floats().append(i)
# Add a segment to the blobby ...
import k3d
context.document.start_change_set()
try:
# Create a FrozenMesh node to act as a mesh source ...
frozen_mesh = k3d.plugin.create("FrozenMesh", context.document)
frozen_mesh.name = "Linear Curve"
# Create a mesh ...
mesh = frozen_mesh.create_mesh()
# Add geometric points to the mesh ...
points = mesh.create_points()
point_selection = mesh.create_point_selection()
positions = [k3d.point3(-5, 0, -5), k3d.point3(5, 0, -5), k3d.point3(-5, 0, 5), k3d.point3(5, 0, 5)]
for position in positions:
points.append(position)
point_selection.append(0.0)
# Create a linear curve primitive ...
curves = k3d.linear_curve.create(mesh)
# Create a custom attribute array to control the width of the curve ...
width = curves.vertex_attributes().create("width", "k3d::double_t")
# Create a custom attribute array to store color values at each curve vertex ...
Cs = curves.vertex_attributes().create("Cs", "k3d::color")
# Add a single curve to the primitive ...
curves.periodic().append(False)
#python
import k3d
positions = [(-5, -5, 0), (5, -5, 0), (5, 5, 0), (-5, 5, 0)]
points = context.output.create_points()
point_selection = context.output.create_point_selection()
for position in positions:
points.append(k3d.point3(position[0], position[1], position[2]))
point_selection.append(0.0)
polyhedron = k3d.polyhedron.create(context.output)
polyhedron.shell_types().append(k3d.polyhedron.shell_type.POLYGONS)
polyhedron.face_shells().append(0)
polyhedron.face_first_loops().append(0)
polyhedron.face_loop_counts().append(1)
polyhedron.face_materials().append(None)
polyhedron.face_selections().append(0.0)
polyhedron.loop_first_edges().append(0)
polyhedron.clockwise_edges().assign([1, 2, 3, 0])
polyhedron.edge_selections().assign([0, 0, 0, 0])
polyhedron.vertex_points().assign([0, 1, 2, 3])
polyhedron.vertex_selections().assign([0, 0, 0, 0])
#python
import k3d
k3d.check_node_environment(locals(), "MeshSourceScript")
from random import uniform
count = 200
size = 10
points = Output.create_points()
point_selection = Output.create_point_selection()
for i in range(count):
points.append(k3d.point3(uniform(-size, size), uniform(-size, size), uniform(-size, size)))
point_selection.append(0.0)
point_groups = Output.create_point_groups()
first_points = point_groups.create_first_points()
first_points.append(0)
point_counts = point_groups.create_point_counts()
point_counts.append(len(points))
materials = point_groups.create_materials()
materials.append(None)
constantwidth = point_groups.writable_constant_data().create("constantwidth", "double")
constantwidth.append(0.2)
# Perform required one-time setup to store bicubic patches in the mesh ...
patches = k3d.bicubic_patch.create(Output)
# Create an (optional) array to hold color values at the parametric
# corners of each patch ...
Cs = patches.varying_data().create("Cs", "k3d::color")
# We will create two identical bicubic patches ...
for i in range(2):
patches.patch_selections().append(0)
patches.patch_materials().append(None)
for j in range(16):
patches.patch_points().append(len(points) + j)
positions = [(-5, -5, 0), (-2, -5, 2), (2, -5, -2), (5, -5, 0),
(-5, -2, 2), (-2, -2, 5), (2, -2, -5), (5, -2, -2),
(-5, 2, 2), (-2, 2, 5), (2, 2, -5), (5, 2, -2), (-5, 5, 0),
(-2, 5, 2), (2, 5, -2), (5, 5, 0)]
for position in positions:
points.append(
k3d.point3(position[0] + (12 * i), position[2], -position[1]))
point_selection.append(0.0)
Cs.append(k3d.color(1, 0, 0))
Cs.append(k3d.color(0, 1, 0))
Cs.append(k3d.color(0, 0, 1))
Cs.append(k3d.color(1, 1, 1))
#python
import k3d
import testing
doc = k3d.new_document()
source = k3d.plugin.create("PolyGrid", doc)
centroid = k3d.plugin.create("PointsCentroid", doc)
source.rows = 1
source.columns = 1
selection = k3d.geometry.selection.create(0)
point_selection = k3d.geometry.point_selection.create(selection)
k3d.geometry.point_selection.append(point_selection, 0, 2, 1)
centroid.mesh_selection = selection
k3d.property.connect(doc, source.get_property("output_mesh"),
centroid.get_property("input_mesh"))
if centroid.centroid != k3d.point3(0, 5, 0):
raise "unexpected output_vector: " + str(centroid.centroid)
test_node = document.new_node("Axes")
test_node.name = "test_node"
create_property(test_container, "k3d::bool_t", True)
create_property(test_container, "k3d::color", k3d.color(1, 2, 3))
create_property(test_container, "k3d::double_t", 3.1415)
create_property(test_container, "k3d::filesystem::path",
k3d.filesystem.generic_path("/foo/bar/baz"))
create_property(test_container, "k3d::gl::imesh_painter*",
test_gl_mesh_painter)
create_property(test_container, "k3d::imaterial*", test_material)
create_property(test_container, "k3d::inode*", test_node)
create_property(test_container, "k3d::int32_t", 19700827)
create_property(test_container, "k3d::matrix4", k3d.scale3(1, 2, 3))
create_property(test_container, "k3d::normal3", k3d.normal3(1, 2, 3))
create_property(test_container, "k3d::point3", k3d.point3(1, 2, 3))
create_property(test_container, "k3d::point4", k3d.point4(1, 2, 3, 4))
create_property(test_container, "k3d::ri::imesh_painter*",
test_ri_mesh_painter)
create_property(test_container, "k3d::ri::itexture*", test_ri_texture)
create_property(test_container, "k3d::string_t", "K-3D Rocks!")
create_property(test_container, "k3d::vector3", k3d.vector3(1, 2, 3))
path = testing.binary_path() + "/document.serialization.properties.output.k3d"
document.save(path)
def test_property(value, expected_value):
if value != expected_value:
raise "property value doesn't match: ", value, expected_value
source_a = document.new_node("FrozenMesh")
source_b = document.new_node("FrozenMesh")
mesh_a = source_a.create_mesh()
mesh_b = source_b.create_mesh()
test_equal(mesh_a, mesh_b, "empty meshes")
points_a = mesh_a.create_points()
test_unequal(mesh_a, mesh_b, "mesh without point array")
points_b = mesh_b.create_points()
test_equal(mesh_a, mesh_b, "meshes with empty point arrays")
points_a.append(k3d.point3(1, 2, 3))
test_unequal(mesh_a, mesh_b, "mismatched point arrays")
points_b.append(k3d.point3(1, 2, 3))
test_equal(mesh_a, mesh_b, "matched point arrays")
primitive_a = mesh_a.primitives().create("foo")
test_unequal(mesh_a, mesh_b, "mesh without primitive")
primitive_b = mesh_b.primitives().create("foo")
test_equal(mesh_a, mesh_b, "matched primitives")
structure_a = primitive_a.structure().create("indices", "k3d::uint_t")
test_unequal(mesh_a, mesh_b, "structure with missing array")
structure_b = primitive_b.structure().create("indices", "k3d::uint_t")
patches = k3d.bezier_triangle_patch.create(context.output) # We will create two identical bezier triangle patches ... for i in range(2): patches.patch_first_points().append(len(points)) patches.patch_orders().append(4) patches.patch_selections().append(0) patches.patch_materials().append(None) # from The Platonic Spheroids at http://www.cise.ufl.edu/research/SurfLab/pre99-papers/97.spheroids.ps.gz # The tetroid: # (3,-3,-3) (1,-1,-7) (-1,1,-7) (-3,3,-3) # (1,-7,-1) (-11,-11,-11) (-7,1,-1) # (-1,-7,1) (-7,-1,1) # (-3,-3,3) positions = [ (3,-3,-3), (1,-7,-1), (1,-1,-7), (-1,-7,1), (-11,-11,-11), (-1,1,-7), (-3,-3,3), (-7,-1,1), (-7,1,-1), (-3,3,-3) ] # Assign patch_points and patch_weights here ... for j in range(0,len(positions)): patches.patch_points().append(len(points) + j) patches.patch_point_weights().append(1) for position in positions: points.append(k3d.point3(position[0] + (12 * i), position[2], -position[1])) point_selection.append(0.0)
#python
import k3d
import sys
import testing
setup = testing.setup_mesh_writer_test(["FrozenMesh", "K3DMeshWriter"], "K3DMeshReader", "mesh.serialization.k3d")
mesh = setup.source.create_mesh()
primitive = mesh.primitives().create("test")
array_types = [ "k3d::bool_t", "k3d::color", "k3d::double_t", "k3d::imaterial*", "k3d::inode*", "k3d::int16_t", "k3d::int32_t", "k3d::int64_t", "k3d::int8_t", "k3d::matrix4", "k3d::normal3", "k3d::point2", "k3d::point3", "k3d::point4", "k3d::string_t", "k3d::texture3", "k3d::uint16_t", "k3d::uint32_t", "k3d::uint64_t", "k3d::uint8_t", "k3d::vector2", "k3d::vector3", "k3d::uint_t" ]
array_values = [ True, k3d.color(1, 2, 3), 1.0, None, None, 1, 2, 3, 4, k3d.identity3(), k3d.normal3(1, 2, 3), k3d.point2(1, 2), k3d.point3(1, 2, 3), k3d.point4(1, 2, 3, 4), "A String", k3d.texture3(1, 2, 3), 1, 2, 3, 4, k3d.vector2(1, 2), k3d.vector3(1, 2, 3), 7 ]
structure = primitive.structure().create("generic")
attributes = primitive.attributes().create("generic")
for i in range(len(array_types)):
type = array_types[i]
value = array_values[i]
structure_array = structure.create(type, type)
structure_array.append(value)
structure_array.append(value)
structure_array.append(value)
attribute_array = attributes.create(type, type)
attribute_array.append(value)
attribute_array.append(value)
attribute_array.append(value)
polyhedron.face_selections().append(0.0)
Cs.append(k3d.color(1, j / 2.0, i / 1.0))
polyhedron.loop_first_edges().append(len(polyhedron.edge_points()))
# Each loop has four edges, each of which points to the next edge in clockwise-order ...
polyhedron.clockwise_edges().append(len(polyhedron.edge_points()) + 1)
polyhedron.clockwise_edges().append(len(polyhedron.edge_points()) + 2)
polyhedron.clockwise_edges().append(len(polyhedron.edge_points()) + 3)
polyhedron.clockwise_edges().append(len(polyhedron.edge_points()) + 0)
# Each edge refers to its starting-point ...
polyhedron.edge_points().append(len(points) + 0)
polyhedron.edge_points().append(len(points) + 1)
polyhedron.edge_points().append(len(points) + 2)
polyhedron.edge_points().append(len(points) + 3)
polyhedron.edge_selections().append(0.0)
polyhedron.edge_selections().append(0.0)
polyhedron.edge_selections().append(0.0)
polyhedron.edge_selections().append(0.0)
positions = [(-5, 0, 5), (5, 0, 5), (5, 0, -5), (-5, 0, -5)]
for position in positions:
points.append(
k3d.point3(position[0] + (j * 11.0), position[1] + (i * -11.0),
position[2]))
point_selection.append(0.0)
# Create a FrozenMesh node to act as a mesh source ...
frozen_mesh = k3d.plugin.create("FrozenMesh", context.document)
frozen_mesh.name = "Particles"
# Create a mesh ...
mesh = frozen_mesh.create_mesh()
particle_count = 100
size = 10
# Add geometric points to the mesh ...
points = mesh.create_points()
point_selection = mesh.create_point_selection()
for i in range(particle_count):
points.append(
k3d.point3(uniform(-size, size), uniform(-size, size),
uniform(-size, size)))
point_selection.append(0.0)
# Create a particle primitive ...
particles = k3d.particle.create(mesh)
# Create a custom attribute array to control the widths of particles ...
constantwidth = particles.constant_attributes().create(
"constantwidth", "k3d::double_t")
# Create a custom attribute array to store color values for each particle ...
Cs = particles.vertex_attributes().create("Cs", "k3d::color")
# Add particles to the primitive ...
particles.material().append(None)
for i in range(particle_count):
polyhedron.loop_first_edges().append(len(polyhedron.clockwise_edges())) # Each loop has four edges, each of which points to the next edge in clockwise-order ... polyhedron.clockwise_edges().append(len(polyhedron.clockwise_edges()) + 1) polyhedron.clockwise_edges().append(len(polyhedron.clockwise_edges()) + 1) polyhedron.clockwise_edges().append(len(polyhedron.clockwise_edges()) + 1) polyhedron.clockwise_edges().append(len(polyhedron.clockwise_edges()) - 3) polyhedron.edge_selections().append(0.0) polyhedron.edge_selections().append(0.0) polyhedron.edge_selections().append(0.0) polyhedron.edge_selections().append(0.0) # Each edge has a vertex that references a mesh point ... polyhedron.vertex_points().append(len(points) + 0) polyhedron.vertex_points().append(len(points) + 1) polyhedron.vertex_points().append(len(points) + 2) polyhedron.vertex_points().append(len(points) + 3) polyhedron.vertex_selections().append(0.0) polyhedron.vertex_selections().append(0.0) polyhedron.vertex_selections().append(0.0) polyhedron.vertex_selections().append(0.0) positions = [(-5, 0, 5), (5, 0, 5), (5, 0, -5), (-5, 0, -5)] for position in positions: points.append(k3d.point3(position[0] + (j * 11.0), position[1] + (i * -11.0), position[2])) point_selection.append(0.0)
polyhedron = k3d.polyhedron.create(mesh)
primitive = mesh.primitives()[0]
if k3d.polyhedron.validate(mesh, primitive):
raise Exception("validate() should fail on polyhedron with missing points.")
mesh.create_points()
if k3d.polyhedron.validate(mesh, primitive):
raise Exception("validate() should fail on polyhedron with missing point_selections.")
mesh.create_point_selection()
if not k3d.polyhedron.validate(mesh, primitive):
raise Exception("validate() should succeed.")
polyhedron.clockwise_edges().append(0)
polyhedron.edge_selections().append(0)
polyhedron.vertex_points().append(0)
polyhedron.vertex_selections().append(0)
if k3d.polyhedron.validate(mesh, primitive):
raise Exception("validate() should fail on polyhedron with out-of-bound point indices.")
mesh.points().append(k3d.point3(0, 0, 0))
mesh.point_selection().append(0)
if not k3d.polyhedron.validate(mesh, primitive):
raise Exception("validate() should succeed.")
#python
from math import radians
import k3d
k3d.check_node_environment(context, "MeshSourceScript")
# Construct a sphere mesh primitive ...
hyperboloid = k3d.hyperboloid.create(context.output)
color = hyperboloid.parameter_attributes().create("Cs", "k3d::color")
# Add two hyperboloids ...
hyperboloid.matrices().append(k3d.translate3(k3d.vector3(-5, 0, 0)))
hyperboloid.materials().append(None)
hyperboloid.start_points().append(k3d.point3(-2, 2, 2))
hyperboloid.end_points().append(k3d.point3(2, 2, -2))
hyperboloid.sweep_angles().append(radians(360))
hyperboloid.selections().append(0)
color.append(k3d.color(1, 0, 0))
color.append(k3d.color(1, 0, 0))
color.append(k3d.color(1, 1, 0))
color.append(k3d.color(1, 1, 0))
hyperboloid.matrices().append(k3d.translate3(k3d.vector3(5, 0, 0)))
hyperboloid.materials().append(None)
hyperboloid.start_points().append(k3d.point3(-2, 2, 2))
hyperboloid.end_points().append(k3d.point3(2, 2, -2))
hyperboloid.sweep_angles().append(radians(360))
hyperboloid.selections().append(0)
color.append(k3d.color(1, 0, 0))
color.append(k3d.color(1, 0, 0))
#python
import k3d
document = k3d.new_document()
pointSubtraction = k3d.plugin.create("PointSubtraction", document)
pointSubtraction.a = k3d.point3(1, 2, 3)
pointSubtraction.b = k3d.point3(3, 2, 1)
if pointSubtraction.a_minus_b != k3d.vector3(-2, 0, 2):
raise Exception("(1, 2, 3) - (3, 2, 1) != (-2, 0, 2)")
#python
import k3d
import sys
import testing
document = k3d.new_document()
source = document.new_node("FrozenMesh")
mesh = source.create_mesh()
primitive = mesh.primitives().create("test")
array_types = [ "k3d::bool_t", "k3d::color", "k3d::double_t", "k3d::imaterial*", "k3d::inode*", "k3d::int16_t", "k3d::int32_t", "k3d::int64_t", "k3d::int8_t", "k3d::matrix4", "k3d::normal3", "k3d::point2", "k3d::point3", "k3d::point4", "k3d::string_t", "k3d::texture3", "k3d::uint16_t", "k3d::uint32_t", "k3d::uint64_t", "k3d::uint8_t", "k3d::vector2", "k3d::vector3", "k3d::uint_t" ]
array_values = [ True, k3d.color(1, 2, 3), 1.0, None, None, 1, 2, 3, 4, k3d.identity3(), k3d.normal3(1, 2, 3), k3d.point2(1, 2), k3d.point3(1, 2, 3), k3d.point4(1, 2, 3, 4), "A String", k3d.texture3(1, 2, 3), 1, 2, 3, 4, k3d.vector2(1, 2), k3d.vector3(1, 2, 3), 7 ]
attributes = primitive.attributes().create("uniform")
for i in range(len(array_types)):
type = array_types[i]
value = array_values[i]
named_array = primitive.structure().create(type, type)
named_array.append(value)
named_array.append(value)
attribute_array = attributes.create(type, type)
attribute_array.append(value)
attribute_array.append(value)
attribute_array.append(value)
print repr(mesh)
sys.stdout.flush()
trim_curve_knots.append(0)
for i in range(1, segments):
trim_curve_knots.append(i)
trim_curve_knots.append(i)
for i in range(0, 3):
trim_curve_knots.append(segments)
#weights
trim_curve_point_weights.append(1)
for i in range(segments):
trim_curve_point_weights.append(weight)
trim_curve_point_weights.append(1)
#trim_curve_point_weights.append(weight)
#control points
X = k3d.point3(1, 0, 0)
Y = k3d.point3(0, 1, 0)
trim_points.append(
math.cos(start_angle) * k3d.point2(0.75, 0.5) +
math.sin(start_angle) * k3d.point2(0.5, 0.75))
for i in range(segments):
a0 = start_angle + (theta * (i))
a2 = start_angle + (theta * (i + 1))
p0 = k3d.point3(math.cos(a0) * X + math.sin(a0) * Y)
p2 = k3d.point3(math.cos(a2) * X + math.sin(a2) * Y)
t0 = k3d.point3(-math.sin(a0) * X + math.cos(a0) * Y)
t2 = k3d.point3(-math.sin(a2) * X + math.cos(a2) * Y)
#python
import k3d
import testing
document = k3d.new_document()
instance = k3d.plugin.create("MeshInstance", document)
transform = k3d.plugin.create("FrozenMatrix", document)
transform.matrix = k3d.translate3(1, 0, 0)
k3d.property.connect(document, transform.get_property("output_matrix"), instance.get_property("input_matrix"))
position = k3d.world_position(instance)
reference = k3d.point3(1, 0, 0)
if position != reference:
raise Exception("Position differs from expected value, expected: " + str(reference) + ", result: " + str(position))
#python
import k3d
document = k3d.new_document()
planeCreation = k3d.plugin.create("PlaneCreation", document)
normal = k3d.vector3(0, 0, 1)
point = k3d.point3(0, 1, 0)
planeCreation.normal = normal
planeCreation.point = point
if planeCreation.plane != k3d.plane(normal, point):
raise Exception("Incorrect plane: " + str(planeCreation.plane))
# Create an array to store per-curve curve colors ...
Cs = curves.curve_attributes().create("Cs", "k3d::color")
# Add some curves ...
curves.periodic().append(False)
curves.material().append(None)
constantwidth.append(0.5)
for j in range(5):
curves.curve_first_points().append(len(curves.curve_points()))
curves.curve_point_counts().append(7)
curves.curve_selections().append(0.0)
curves.curve_points().append(len(points) + 0)
curves.curve_points().append(len(points) + 1)
curves.curve_points().append(len(points) + 2)
curves.curve_points().append(len(points) + 3)
curves.curve_points().append(len(points) + 4)
curves.curve_points().append(len(points) + 5)
curves.curve_points().append(len(points) + 6)
positions = [(0, 0, 5), (-5, 0, 5), (-5, 0, 0), (0, 0, 0), (5, 0, 0),
(5, 0, -5), (0, 0, -5)]
for position in positions:
points.append(
k3d.point3(position[0] + (j * 5), position[1], position[2]))
point_selection.append(0.0)
Cs.append(k3d.color(1, 1, j * 0.2))
#python
import k3d
k3d.check_node_environment(context, "MeshSourceScript")
blobby = k3d.blobby.create(context.output)
Cs = blobby.parameter_attributes().create("Cs", "k3d::color")
# Add four ellipsoids to the blobby ...
ellipsoids = [k3d.point3(-1, 0, 1), k3d.point3(1, 0, 1), k3d.point3(1, 0, -1), k3d.point3(-1, 0, -1)]
blobby.first_primitives().append(len(blobby.primitives()))
blobby.primitive_counts().append(len(ellipsoids) + 1)
blobby.first_operators().append(len(blobby.operators()))
blobby.operator_counts().append(1)
blobby.materials().append(k3d.node.lookup_one(context.document, "Material"))
for center in ellipsoids:
blobby.primitives().append(k3d.blobby.primitive_type.ELLIPSOID)
blobby.primitive_first_floats().append(len(blobby.floats()))
blobby.primitive_float_counts().append(16)
for i in (k3d.translate3(center[0], center[1], center[2]) * k3d.scale3(1)).column_major_values():
blobby.floats().append(i)
# Add a segment to the blobby ...
blobby.primitives().append(k3d.blobby.primitive_type.SEGMENT)
blobby.primitive_first_floats().append(len(blobby.floats()))
blobby.primitive_float_counts().append(23)
blobby.floats().append(-1)
blobby.floats().append(0)
blobby.floats().append(0)
array_types = [
"k3d::bool_t", "k3d::color", "k3d::double_t", "k3d::imaterial*",
"k3d::inode*", "k3d::int16_t", "k3d::int32_t", "k3d::int64_t",
"k3d::int8_t", "k3d::matrix4", "k3d::normal3", "k3d::point2",
"k3d::point3", "k3d::point4", "k3d::string_t", "k3d::texture3",
"k3d::uint16_t", "k3d::uint32_t", "k3d::uint64_t", "k3d::uint8_t",
"k3d::vector2", "k3d::vector3", "k3d::uint_t"
]
array_values = [
True,
k3d.color(1, 2, 3), 1.0, None, None, 1, 2, 3, 4,
k3d.identity3(),
k3d.normal3(1, 2, 3),
k3d.point2(1, 2),
k3d.point3(1, 2, 3),
k3d.point4(1, 2, 3, 4), "A String",
k3d.texture3(1, 2, 3), 1, 2, 3, 4,
k3d.vector2(1, 2),
k3d.vector3(1, 2, 3), 7
]
structure = primitive.structure().create("generic")
attributes = primitive.attributes().create("generic")
for i in range(len(array_types)):
type = array_types[i]
value = array_values[i]
structure_array = structure.create(type, type)
structure_array.append(value)
patches.patch_point_weights().append(0.5)
patches.patch_point_weights().append(1)
patches.patch_u_knots().append(1)
patches.patch_u_knots().append(1)
patches.patch_u_knots().append(1)
patches.patch_u_knots().append(2)
patches.patch_u_knots().append(2)
patches.patch_u_knots().append(2)
patches.patch_v_knots().append(1)
patches.patch_v_knots().append(1)
patches.patch_v_knots().append(2)
patches.patch_v_knots().append(2)
patches.patch_first_trim_loops().append(0)
patches.patch_trim_loop_counts().append(0)
# Cs.append(k3d.color(1, 0, 0))
# Cs.append(k3d.color(0, 1, 0))
# Cs.append(k3d.color(0, 0, 1))
# Cs.append(k3d.color(1, 1, 1))
positions = [(-5, 5, 5), (5, 5, 5), (5, 5, 10), (-5, -5, 5), (5, -5, 5),
(5, -5, 10)]
for position in positions:
points.append(
k3d.point3(position[0], position[1], position[2] + (i * -10)))
point_selection.append(0.0)
frozen_mesh = k3d.plugin.create("FrozenMesh", context.document)
frozen_mesh.name = function
# Create a mesh ...
mesh = frozen_mesh.create_mesh()
# Add geometric points to the mesh ...
points = mesh.create_points()
point_selection = mesh.create_point_selection()
for xi in range(0, xcount):
for yi in range(0, ycount):
x = mix(x1, x2, float(xi) / (xcount - 1))
y = mix(y1, y2, float(yi) / (ycount - 1))
z = eval(function)
points.append(k3d.point3(x, y, z))
point_selection.append(0.0)
# Create a particle primitive ...
particles = k3d.particle.create(mesh)
# Create a custom attribute array to control the widths of particles ...
constantwidth = particles.constant_attributes().create(
"constantwidth", "k3d::double_t")
particles.material().append(None)
constantwidth.append(0.2)
for i in range(len(points)):
particles.points().append(i)
source_a = k3d.plugin.create("FrozenMesh", document)
source_b = k3d.plugin.create("FrozenMesh", document)
mesh_a = source_a.create_mesh()
mesh_b = source_b.create_mesh()
test_equal(mesh_a, mesh_b, "empty meshes")
points_a = mesh_a.create_points()
test_unequal(mesh_a, mesh_b, "mesh without point array")
points_b = mesh_b.create_points()
test_equal(mesh_a, mesh_b, "meshes with empty point arrays")
points_a.append(k3d.point3(1, 2, 3))
test_unequal(mesh_a, mesh_b, "mismatched point arrays")
points_b.append(k3d.point3(1, 2, 3))
test_equal(mesh_a, mesh_b, "matched point arrays")
primitive_a = mesh_a.primitives().create("foo")
test_unequal(mesh_a, mesh_b, "mesh without primitive")
primitive_b = mesh_b.primitives().create("foo")
test_equal(mesh_a, mesh_b, "matched primitives")
structure_a = primitive_a.structure().create("uniform")
test_unequal(mesh_a, mesh_b, "primitive with missing structure")
structure_b = primitive_b.structure().create("uniform")
