def create_GeomNode_Single_Point(color_vec4=Vec4(1., 1., 1., 1.)):
# ---- step 1: create point at (0,0,0) and close the primitive
format = GeomVertexFormat.getV3c4()
vdata = GeomVertexData("colored_point", format, Geom.UHStatic)
vdata.setNumRows(4)
# add color to each vertex
colorWriter = GeomVertexWriter(vdata, "color")
# add a vertex position to each vertex
vertexPosWriter = GeomVertexWriter(vdata, "vertex")
# just one origin point vertex, it gets transformed later
# to it's intended position
vertexPosWriter.addData3f(0., 0., 0.)
colorWriter.addData4f(color_vec4)
# build the primitive
pointsprimitive = GeomPoints(Geom.UHStatic)
pointsprimitive.addVertex(0)
pointsprimitive.closePrimitive() # this resets all the data contained in the vertexPosWriter and colorWriter
# ----- step 3: make a GeomNode out of the Geom (to which the Primitives have been added)
# make a Geom object to hold the primitives
geom = Geom(vdata)
geom.addPrimitive(pointsprimitive)
geom_node = GeomNode("colored_point_node")
geom_node.addGeom(geom)
return geom_node
def makeGeom(self, points, colors, sizes):
#format = GeomVertexFormat.getV3c4()
array = GeomVertexArrayFormat()
array.addColumn(InternalName.make('vertex'), 3, Geom.NTFloat32,
Geom.CPoint)
array.addColumn(InternalName.make('color'), 4, Geom.NTFloat32,
Geom.CColor)
array.addColumn(InternalName.make('size'), 1, Geom.NTFloat32,
Geom.COther)
format = GeomVertexFormat()
format.addArray(array)
format = GeomVertexFormat.registerFormat(format)
vdata = GeomVertexData('vdata', format, Geom.UH_static)
vdata.unclean_set_num_rows(len(points))
self.vwriter = GeomVertexWriter(vdata, 'vertex')
self.colorwriter = GeomVertexWriter(vdata, 'color')
self.sizewriter = GeomVertexWriter(vdata, 'size')
geompoints = GeomPoints(Geom.UH_static)
geompoints.reserve_num_vertices(len(points))
index = 0
for (point, color, size) in zip(points, colors, sizes):
self.vwriter.addData3f(*point)
self.colorwriter.addData4f(*color)
self.sizewriter.addData1f(size)
geompoints.addVertex(index)
geompoints.closePrimitive()
index += 1
geom = Geom(vdata)
geom.addPrimitive(geompoints)
return geom
def makePoints(n=1000):
""" make a cloud of points that are a single node VS branching and making subnodes to control display """
#points = np.random.uniform(-10,10,(n,4))
#points = np.random.randn(n,3)
points = np.cumsum(np.random.randint(-1, 2, (n, 3)),
axis=0) #classic random walk
#colors = np.random.rand(n,4)
clr4 = np.random.rand(1, 4)
#points = [(0,0,0)]
fmt = GeomVertexFormat.getV3c4() #3 component vertex, w/ 4 comp color
vertexData = GeomVertexData('points', fmt, Geom.UHStatic)
verts = GeomVertexWriter(vertexData, 'vertex')
color = GeomVertexWriter(vertexData, 'color')
#for point,clr4 in zip(points,colors):
for point in points:
verts.addData3f(*point)
#color.addData4f(*point)
color.addData4f(*clr4[0])
#color.addData4f(.1,.1,.1,1)
#pointCloud = GeomLinestrips(Geom.UHStatic) #this is f*****g cool!
#pointCloud = GeomTristrips(Geom.UHStatic) #this is f*****g cool!
pointCloud = GeomPoints(Geom.UHStatic)
pointCloud.addConsecutiveVertices(0, n) #warning may error since n-1?
pointCloud.closePrimitive()
cloud = Geom(vertexData)
cloud.addPrimitive(pointCloud)
return cloud
def makeSprite(name, texture, scale, add = False):
from panda3d.core import (GeomVertexFormat, GeomVertexData, GeomEnums,
InternalName, GeomVertexWriter, GeomPoints,
Geom, GeomNode, NodePath, TextureStage,
TexGenAttrib, BoundingSphere)
format = GeomVertexFormat.getV3()
data = GeomVertexData(name + "_data", format, GeomEnums.UHStatic)
writer = GeomVertexWriter(data, InternalName.getVertex())
writer.addData3f((0, 0, 0))
primitive = GeomPoints(GeomEnums.UHStatic)
primitive.addVertex(0)
primitive.closePrimitive()
geom = Geom(data)
geom.addPrimitive(primitive)
geomNode = GeomNode(name)
geomNode.addGeom(geom)
np = NodePath(geomNode)
np.setLightOff(1)
np.setMaterialOff(1)
np.setRenderModePerspective(True)
ts = TextureStage('sprite')
if add:
ts.setMode(TextureStage.MAdd)
np.setTexture(ts, texture)
np.setTexGen(ts, TexGenAttrib.MPointSprite)
np.setDepthWrite(False)
np.setDepthOffset(1)
np.setTransparency(True)
np.node().setBounds(BoundingSphere((0, 0, 0), 1))
np.node().setFinal(True)
np.flattenStrong()
np.setScale(scale)
return np
def makePoints(n=1000):
""" make a cloud of points that are a single node VS branching and making subnodes to control display """
#points = np.random.uniform(-10,10,(n,4))
#points = np.random.randn(n,3)
points = np.cumsum(np.random.randint(-1,2,(n,3)), axis=0) #classic random walk
#colors = np.random.rand(n,4)
clr4 = np.random.rand(1,4)
#points = [(0,0,0)]
fmt = GeomVertexFormat.getV3c4() #3 component vertex, w/ 4 comp color
vertexData = GeomVertexData('points', fmt, Geom.UHStatic)
verts = GeomVertexWriter(vertexData, 'vertex')
color = GeomVertexWriter(vertexData, 'color')
#for point,clr4 in zip(points,colors):
for point in points:
verts.addData3f(*point)
#color.addData4f(*point)
color.addData4f(*clr4[0])
#color.addData4f(.1,.1,.1,1)
#pointCloud = GeomLinestrips(Geom.UHStatic) #this is f*****g cool!
#pointCloud = GeomTristrips(Geom.UHStatic) #this is f*****g cool!
pointCloud = GeomPoints(Geom.UHStatic)
pointCloud.addConsecutiveVertices(0,n) #warning may error since n-1?
pointCloud.closePrimitive()
cloud = Geom(vertexData)
cloud.addPrimitive(pointCloud)
return cloud
def draw_rain_mesh(self):
_format = GeomVertexFormat.get_v3cp()
self.rain_vdata = GeomVertexData('rain', _format, Geom.UHDynamic)
self.rain_vdata.setNumRows(self.n_points**2)
vertex = GeomVertexWriter(self.rain_vdata, 'vertex')
color = GeomVertexWriter(self.rain_vdata, 'color')
for j in range(self.n_points):
for i in range(self.n_points):
# Rain Vertices
vertex.addData3f(self.x[j][i], self.y[j][i], self.n_points)
# Rain Colors
color.addData4f(0.3, 0.3, 1, 0)
# Rain Primitive
prim = GeomPoints(Geom.UHDynamic)
for j in range(self.n_points):
for i in range(self.n_points):
prim.add_vertices(j * (self.n_points) + i,
j * (self.n_points) + i,
j * (self.n_points) + i)
geom = Geom(self.rain_vdata)
prim.closePrimitive()
geom.addPrimitive(prim)
node = GeomNode('gnode')
node.addGeom(geom)
rain_nodePath = render.attachNewNode(node)
rain_nodePath.setTransparency(TransparencyAttrib.MAlpha)
rain_nodePath.setAntialias(AntialiasAttrib.MAuto)
rain_nodePath.setRenderModeThickness(2)
rain_nodePath.setPos(-50, -50, 0)
def __init__(self):
ShowBase.__init__(self)
PanditorDisableMouseFunc()
camera.setPos(0.0, 0.0, 50.0)
camera.lookAt(0.0)
PanditorEnableMouseFunc()
# 1) create GeomVertexData
frmt = GeomVertexFormat.getV3n3cp()
vdata = GeomVertexData('triangle', frmt, Geom.UHDynamic)
# 2) create Writers/Rewriters (must all be created before any readers and readers are one-pass-temporary)
vertex = GeomVertexRewriter(vdata, 'vertex')
normal = GeomVertexRewriter(vdata, 'normal')
color = GeomVertexRewriter(vdata, 'color')
zUp = Vec3(0, 0, 1)
wt = Vec4(1.0, 1.0, 1.0, 1.0)
gr = Vec4(0.5, 0.5, 0.5, 1.0)
# 3) write each column on the vertex data object (for speed, have a different writer for each column)
def addPoint(x, y, z):
vertex.addData3f(x, y, z)
normal.addData3f(zUp)
color.addData4f(wt)
addPoint(0.0, 0.0, 0.0)
addPoint(5.0, 0.0, 0.0)
addPoint(0.0, 5.0, 0.0)
addPoint(5.0, 5.0, 0.0)
# 4) create a primitive and add the vertices via index (not truely associated with the actual vertex table, yet)
tris = GeomTriangles(Geom.UHDynamic)
tris.addVertices(0, 1, 2)
tris.closePrimitive(
) # exception thrown if verts added != 3, other types inform Panda how many verts/primitive
tris.addVertices(2, 1, 3)
print "vdataPoints", vdata.getArrays()[0]
# 5.1) (adding to scene) create a Geom and add primitives of like base-type i.e. triangles and triangle strips
geom = Geom(vdata)
geom.addPrimitive(tris)
# 5.2) create a GeomNode to hold the Geom(s) and add the Geom(s)
gn = GeomNode('gnode')
gn.addGeom(geom)
# 5.3) attache the node to the scene
gnNodePath = render.attachNewNode(gn)
geomPts = Geom(vdata)
pts = GeomPoints(Geom.UHStatic)
pts.addVertices(0, 1, 2)
pts.closePrimitive()
geomPts.addPrimitive(pts)
pointsNode = GeomNode('points_node')
pointsNode.addGeom(geomPts)
pointsNP = render.attachNewNode(pointsNode)
pointsNP.setZ(0.5)
render.ls()
def __init__(self, base, obj, **kwargs):
super(GalaxyView, self).__init__(base, obj, **kwargs)
array = GeomVertexArrayFormat()
array.addColumn(InternalName.make('vertex'), 3, Geom.NTFloat32,
Geom.CPoint)
array.addColumn(InternalName.make('color'), 4, Geom.NTFloat32,
Geom.CColor)
array.addColumn(InternalName.make('size'), 1, Geom.NTFloat32,
Geom.COther)
gmformat = GeomVertexFormat()
gmformat.addArray(array)
gmformat = GeomVertexFormat.registerFormat(gmformat)
vdata = GeomVertexData('points', gmformat, Geom.UHDynamic)
vertex = GeomVertexWriter(vdata, 'vertex')
color = GeomVertexWriter(vdata, 'color')
size = GeomVertexWriter(vdata, 'size')
self.node = NodePath('galaxy')
self.node.reparentTo(self.base.render)
self.node.setTransparency(TransparencyAttrib.MAlpha)
lumsort = sorted([star.luminosity for star in self.obj.stars])
#highest_luminosity = lumsort[-1]
median_luminosity = lumsort[len(lumsort) / 2]
for star in self.obj.stars:
vertex.addData3f(star.galpos.x, star.galpos.y, star.galpos.z)
color.addData4f(star.red, star.green, star.blue, 1.0)
#size.addData1f(min(100, max(5, 10-star.magnitude/2)))
sizeval = 10 + log(star.luminosity)
size.addData1f(min(30, max(10, sizeval)))
prim = GeomPoints(Geom.UHStatic)
prim.addConsecutiveVertices(0, len(self.obj.stars))
prim.closePrimitive()
geom = Geom(vdata)
geom.addPrimitive(prim)
node = GeomNode('gnode')
node.addGeom(geom)
galaxy_node = self.node.attachNewNode(node)
galaxy_node.setRenderModeThickness(1)
ts = TextureStage.getDefault() #TextureStage('ts')
#ts.setMode(TextureStage.MGlow)
galaxy_node.setTexGen(ts, TexGenAttrib.MPointSprite)
galaxy_node.setTexture(
ts, self.base.loader.loadTexture('texture/flare.png'))
#galaxy_node.setRenderModePerspective(True)
galaxy_node.setBin("unsorted", 1)
galaxy_node.setDepthWrite(0)
galaxy_node.setTransparency(1)
self.setup_glow_shader()
"""
def __init__(self):
ShowBase.__init__(self)
PanditorDisableMouseFunc()
camera.setPos(0.0, 0.0, 50.0)
camera.lookAt(0.0)
PanditorEnableMouseFunc()
# 1) create GeomVertexData
frmt = GeomVertexFormat.getV3n3cp()
vdata = GeomVertexData('triangle', frmt, Geom.UHDynamic)
# 2) create Writers/Rewriters (must all be created before any readers and readers are one-pass-temporary)
vertex = GeomVertexRewriter(vdata, 'vertex')
normal = GeomVertexRewriter(vdata, 'normal')
color = GeomVertexRewriter(vdata, 'color')
zUp = Vec3(0, 0, 1)
wt = Vec4(1.0, 1.0, 1.0, 1.0)
gr = Vec4(0.5, 0.5, 0.5, 1.0)
# 3) write each column on the vertex data object (for speed, have a different writer for each column)
def addPoint(x, y, z):
vertex.addData3f(x, y, z)
normal.addData3f(zUp)
color.addData4f(wt)
addPoint(0.0, 0.0, 0.0)
addPoint(5.0, 0.0, 0.0)
addPoint(0.0, 5.0, 0.0)
addPoint(5.0, 5.0, 0.0)
# 4) create a primitive and add the vertices via index (not truely associated with the actual vertex table, yet)
tris = GeomTriangles(Geom.UHDynamic)
tris.addVertices(0, 1, 2)
tris.closePrimitive() # exception thrown if verts added != 3, other types inform Panda how many verts/primitive
tris.addVertices(2, 1, 3)
print "vdataPoints", vdata.getArrays()[0]
# 5.1) (adding to scene) create a Geom and add primitives of like base-type i.e. triangles and triangle strips
geom = Geom(vdata)
geom.addPrimitive(tris)
# 5.2) create a GeomNode to hold the Geom(s) and add the Geom(s)
gn = GeomNode('gnode')
gn.addGeom(geom)
# 5.3) attache the node to the scene
gnNodePath = render.attachNewNode(gn)
geomPts = Geom(vdata)
pts = GeomPoints(Geom.UHStatic)
pts.addVertices(0, 1, 2)
pts.closePrimitive()
geomPts.addPrimitive(pts)
pointsNode = GeomNode('points_node')
pointsNode.addGeom(geomPts)
pointsNP = render.attachNewNode(pointsNode)
pointsNP.setZ(0.5)
render.ls()
def makePoint(point=(0,0,0)):
clr4 = [1,1,1,1]
fmt = GeomVertexFormat.getV3c4() #3 component vertex, w/ 4 comp color
vertexData = GeomVertexData('points', fmt, Geom.UHStatic)
verts = GeomVertexWriter(vertexData, 'vertex')
verts.addData3f(*point)
color = GeomVertexWriter(vertexData, 'color')
color.addData4f(*clr4)
pointCloud = GeomPoints(Geom.UHStatic)
pointCloud.addVertex(0)
pointCloud.closePrimitive()
cloud = Geom(vertexData)
cloud.addPrimitive(pointCloud)
cloudNode = GeomNode('point')
cloudNode.addGeom(cloud)
return cloudNode
def makePoint(point=(0, 0, 0)):
clr4 = [1, 1, 1, 1]
fmt = GeomVertexFormat.getV3c4() #3 component vertex, w/ 4 comp color
vertexData = GeomVertexData('points', fmt, Geom.UHStatic)
verts = GeomVertexWriter(vertexData, 'vertex')
verts.addData3f(*point)
color = GeomVertexWriter(vertexData, 'color')
color.addData4f(*clr4)
pointCloud = GeomPoints(Geom.UHStatic)
pointCloud.addVertex(0)
pointCloud.closePrimitive()
cloud = Geom(vertexData)
cloud.addPrimitive(pointCloud)
cloudNode = GeomNode('point')
cloudNode.addGeom(cloud)
return cloudNode
def draw_vert(self, v, v_color):
format = GeomVertexFormat.getV3cp()
vdata = GeomVertexData('vert', format, Geom.UHDynamic)
vertex = GeomVertexWriter(vdata, 'vertex')
color = GeomVertexWriter(vdata, 'color')
vertex.addData3f(0.0, 0.0, 0.0)
color.addData4f(v_color)
mesh = Geom(vdata)
point = GeomPoints(Geom.UHDynamic)
point.addVertex(0)
point.closePrimitive()
mesh.addPrimitive(point)
vert_node = GeomNode(self.mesh.name + '_vert_' + str(v.ID))
vert_node.addGeom(mesh)
vert_node.setTag('ID', str(v.ID))
rendered_vert = self.render_root.attachNewNode(vert_node)
rendered_vert.setPos(v.pos.x, v.pos.y, v.pos.z)
rendered_vert.setRenderModeThickness(5.0)
self.render_nodes['vert_' + str(v.ID)] = rendered_vert
def draw_vert(self,v, v_color):
format = GeomVertexFormat.getV3cp()
vdata=GeomVertexData('vert', format, Geom.UHDynamic)
vertex=GeomVertexWriter(vdata, 'vertex')
color=GeomVertexWriter(vdata, 'color')
vertex.addData3f(0.0,0.0,0.0)
color.addData4f(v_color)
mesh = Geom(vdata)
point = GeomPoints(Geom.UHDynamic)
point.addVertex(0)
point.closePrimitive()
mesh.addPrimitive(point)
vert_node = GeomNode(self.mesh.name+'_vert_'+str(v.ID))
vert_node.addGeom(mesh)
vert_node.setTag('ID',str(v.ID))
rendered_vert = self.render_root.attachNewNode(vert_node)
rendered_vert.setPos(v.pos.x,v.pos.y,v.pos.z)
rendered_vert.setRenderModeThickness(5.0)
self.render_nodes['vert_'+str(v.ID)] = rendered_vert
def load_pcd_content(content,
w=2,
color_mode="intensity",
intensity_filter=50):
pc = pypcd.PointCloud.from_buffer(content)
fmt = GeomVertexFormat() #3 component vertex, w/ 4 comp color
fmt_arr = GeomVertexArrayFormat()
fmt_arr.addColumn(InternalName.make('vertex'), 3, Geom.NTFloat32,
Geom.CPoint)
fmt_color_arr = GeomVertexArrayFormat()
fmt_color_arr.addColumn(InternalName.make('color'), 4, Geom.NTUint8,
Geom.CColor)
fmt.addArray(fmt_arr)
fmt.addArray(fmt_color_arr)
fmt = GeomVertexFormat.registerFormat(fmt)
vertexData = GeomVertexData('points', fmt, Geom.UHStatic)
pointCloud = GeomPoints(Geom.UHStatic)
pc.pc_data.dtype = numpy.dtype("<f4")
v, c = arrayfilter.vertices_filter(pc.pc_data.reshape((pc.points, 4)))
for i in xrange(len(v)):
pointCloud.addVertex(i)
pointCloud.closePrimitive()
arr = GeomVertexArrayData(fmt.getArray(0), GeomEnums.UHStream)
datahandle = arr.modifyHandle()
datahandle.copyDataFrom(v)
vertexData.setArray(0, arr)
arr = GeomVertexArrayData(fmt.getArray(1), GeomEnums.UHStream)
datahandle = arr.modifyHandle()
datahandle.copyDataFrom(c)
vertexData.setArray(1, arr)
cloud = Geom(vertexData)
cloud.addPrimitive(pointCloud)
cloudNode = GeomNode('points')
cloudNode.addGeom(cloud)
cloudNodePath = NodePath(cloudNode)
cloudNodePath.setRenderModeThickness(w)
cloudNodePath.setRenderModePerspective(True)
return cloudNode
def make_cloud_node(pts, col=LColorf(1.0, 0.0, 0.0, 1.0)):
ptCloudData = GeomVertexData("PointCloudData", GeomVertexFormat.getV3c4(),
GeomEnums.UH_static)
vertexWriter = GeomVertexWriter(ptCloudData, Thread.getCurrentThread())
vertexWriter.setColumn("vertex")
colorWriter = GeomVertexWriter(ptCloudData, Thread.getCurrentThread())
colorWriter.setColumn("color")
for (x, y, z) in pts:
vertexWriter.addData3(x, y, z)
colorWriter.addData4(col)
geomPts = GeomPoints(GeomEnums.UH_static)
geomPts.addConsecutiveVertices(0, len(pts))
geomPts.closePrimitive()
geom = Geom(ptCloudData)
geom.addPrimitive(geomPts)
node = GeomNode("PointCloudNode")
node.addGeom(geom, RenderState.makeEmpty())
return node
class UI(ShowBase):
def __init__(self):
ShowBase.__init__(self)
vertexFormat = GeomVertexFormat.getV3c4()
self.vertexData = GeomVertexData("data", vertexFormat, Geom.UHDynamic)
geometry = Geom(self.vertexData)
self.primitive = GeomPoints(Geom.UHDynamic)
geometry.addPrimitive(self.primitive)
node = GeomNode("node")
node.addGeom(geometry)
self.nodePath = NodePath(node)
self.nodePath.setPos(0, 0, 0)
self.nodePath.setRenderModeThickness(10.0)
self.camera.setPos(0.0, -10.0, 0.0)
self.disableMouse()
self.nodePath.reparentTo(self.render)
def add_task(self, task):
def task_wrapper(taskObject):
task()
return Task.cont
self.taskMgr.add(task_wrapper)
def set_points(self, position, color):
assert len(position) == len(color)
self.vertexData.setNumRows(len(position))
self.primitive.clearVertices()
for i in range(len(position)):
self.primitive.addVertex(i)
self.primitive.closePrimitive()
positionWriter = GeomVertexWriter(self.vertexData, "vertex")
colorWriter = GeomVertexWriter(self.vertexData, "color")
for p, c in zip(position, color):
positionWriter.addData3f(p[0], p[1], p[2])
colorWriter.addData4f(c[0], c[1], c[2], c[3])
#altRender.setLight(dlnp)
#altRender.setLight(alnp)
# vertex writer
vdata = GeomVertexData('points', GeomVertexFormat.getV3(), Geom.UHDynamic)
vwriter = GeomVertexWriter(vdata, 'vertex')
# 100 randomly generated vertex coordinates
for i in range(100):
vwriter.addData3f(uniform(-100, 100), uniform(-100, 100),
uniform(-100, 100))
# create geom
points = GeomPoints(Geom.UHDynamic)
points.addNextVertices(100)
points.closePrimitive()
geo = Geom(vdata)
geo.addPrimitive(points)
gnode = GeomNode('points')
gnode.addGeom(geo)
np = render.attachNewNode(gnode)
# point sprite effect
np.setTransparency(TransparencyAttrib.MDual)
np.setTexGen(TextureStage.getDefault(), TexGenAttrib.MPointSprite)
np.setTexture(altBuffer.getTexture())
np.setRenderModePerspective(True)
np.setRenderModeThickness(8)
# additional controls
