from math import *
import sys, time
+# Constants
+EPS = 10e-5
+
# Some global settings
class config:
polygons = dict()
polygons['SHOW'] = True
- polygons['SHADING'] = 'FLAT'
- polygons['HSR'] = 'PAINTER' # 'PAINTER' or 'NEWELL'
- #polygons['HSR'] = 'NEWELL'
+ polygons['SHADING'] = 'TOON'
+ #polygons['HSR'] = 'PAINTER' # 'PAINTER' or 'NEWELL'
+ polygons['HSR'] = 'NEWELL'
# Hidden to the user for now
polygons['EXPANSION_TRICK'] = True
edges = dict()
edges['SHOW'] = False
edges['SHOW_HIDDEN'] = False
- edges['STYLE'] = 'MESH'
+ edges['STYLE'] = 'MESH' # or SILHOUETTE
edges['WIDTH'] = 2
edges['COLOR'] = [0, 0, 0]
-# Debug utility function
-print_debug = False
-def debug(msg):
- if print_debug:
- sys.stderr.write(msg)
+# Utility functions
+def sign(x):
+
+ if x < 0:
+ return -1
+ elif x > 0:
+ return 1
+ #else:
+ # return 0
# ---------------------------------------------------------------------
self.refresh_rate = 10
self.shows_counter = 0
+ self.quiet = False
+
self.progressModel = None
+ def setQuiet(self, value):
+ self.quiet = value
+
def setActivity(self, name, steps):
"""Initialize the Model.
assert(self.progressModel)
if self.progressModel.update():
+ if self.quiet:
+ return
+
self.show(self.progressModel.getProgress(),
self.progressModel.getName())
if color[3] != 255:
opacity = float(color[3])/255.0
opacity_string = " fill-opacity: %g; stroke-opacity: %g; opacity: 1;" % (opacity, opacity)
+ #opacity_string = "opacity: %g;" % (opacity)
self.file.write("\tstyle=\"fill:" + str_col + ";")
self.file.write(opacity_string)
# see http://www.antigrain.com/svg/index.html for more info
stroke_width = 1.0
- if config.polygons['EXPANSION_TRICK']:
+ # EXPANSION TRICK is not that useful where there is transparency
+ if config.polygons['EXPANSION_TRICK'] and color[3] == 255:
+ # str_col = "#000000" # For debug
self.file.write(" stroke:%s;\n" % str_col)
self.file.write(" stroke-width:" + str(stroke_width) + ";\n")
self.file.write(" stroke-linecap:round;stroke-linejoin:round")
Objects = workScene.getChildren()
print "Total Objects: %d" % len(Objects)
for i,obj in enumerate(Objects):
+ print "\n\n-------"
print "Rendering Object: %d" % i
if obj.getType() != 'Mesh':
mesh = obj.getData(mesh=1)
+ # Triangolarize the mesh??
+ for f in mesh.faces: f.sel = 1
+ mesh.quadToTriangle()
+
self._doModelingTransformation(mesh, obj.matrix)
self._doBackFaceCulling(mesh)
+ # When doing HSR with NEWELL we may want to flip all normals
+ # toward the viewer
+ if config.polygons['HSR'] == "NEWELL":
+ for f in mesh.faces:
+ f.sel = 1-f.sel
+ mesh.flipNormals()
+ for f in mesh.faces:
+ f.sel = 1
+
self._doLighting(mesh)
+
# Do "projection" now so we perform further processing
# in Normalized View Coordinates
self._doProjection(mesh, self.proj)
"""Convert all "geometric" objects to mesh ones.
"""
geometricObjTypes = ['Mesh', 'Surf', 'Curve', 'Text']
+ #geometricObjTypes = ['Mesh', 'Surf', 'Curve']
Objects = scene.getChildren()
objList = [ o for o in Objects if o.getType() in geometricObjTypes ]
mat = None
if materials:
mat = materials[f.mat]
- # Check if it is a shadeless material
- if mat.getMode() & Material.Modes['SHADELESS']:
- I = mat.getRGBCol()
- # Convert to a value between 0 and 255
- tmp_col = [ int(c * 255.0) for c in I]
-
- for c in f.col:
- c.r = tmp_col[0]
- c.g = tmp_col[1]
- c.b = tmp_col[2]
- #c.a = tmp_col[3]
-
- continue
-
-
# A new default material
if mat == None:
mat = Material.New('defMat')
+ # Check if it is a shadeless material
+ elif mat.getMode() & Material.Modes['SHADELESS']:
+ I = mat.getRGBCol()
+ # Convert to a value between 0 and 255
+ tmp_col = [ int(c * 255.0) for c in I]
+
+ for c in f.col:
+ c.r = tmp_col[0]
+ c.g = tmp_col[1]
+ c.b = tmp_col[2]
+ #c.a = tmp_col[3]
+
+ continue
+
+
# do vertex color calculation
TotDiffSpec = Vector([0.0, 0.0, 0.0])
for l in self.lights:
light_obj = l
light_pos = self._getObjPosition(l)
- light = light_obj.data
+ light = light_obj.getData()
L = Vector(light_pos).normalize()
# The sorting requires circa n*log(n) steps
n = len(mesh.faces)
progress.setActivity("HSR: Painter", n*log(n))
-
by_furthest_z = (lambda f1, f2: progress.update() and
- cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2]))
+ cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2])+EPS)
)
# FIXME: using NMesh to sort faces. We should avoid that!
nmesh.update()
- def __topologicalDepthSort(self, mesh):
- """Occlusion based on topological occlusion.
-
- Build the occlusion graph of the mesh,
- and then do topological sort on that graph
- """
- return
-
def __newellDepthSort(self, mesh):
"""Newell's depth sorting.
"""
- by_furthest_z = (lambda f1, f2:
- cmp(max([v.co[2] for v in f1]), max([v.co[2] for v in f2]))
- )
-
- def Distance(point, face):
- """ Calculate the distance between a point and a face.
-
- An alternative but more expensive method can be:
-
- ip = Intersect(Vector(face[0]), Vector(face[1]), Vector(face[2]),
- Vector(face.no), Vector(point), 0)
-
- d = Vector(ip - point).length
- """
- plNormal = Vector(face.no)
- plVert0 = Vector(face[0])
+ from hsrtk import *
- #d = abs( (point * plNormal ) - (plVert0 * plNormal) )
- d = (point * plNormal ) - (plVert0 * plNormal)
- debug("d: "+ str(d) + "\n")
+ # Find non planar quads and convert them to triangle
+ #for f in mesh.faces:
+ # f.sel = 0
+ # if is_nonplanar_quad(f.v):
+ # print "NON QUAD??"
+ # f.sel = 1
- return d
+ # Now reselect all faces
+ for f in mesh.faces:
+ f.sel = 1
# FIXME: using NMesh to sort faces. We should avoid that!
nmesh = NMesh.GetRaw(mesh.name)
facelist = nmesh.faces[:]
maplist = []
- EPS = 10e-7
+ # The steps are _at_least_ equal to len(facelist), we do not count the
+ # feces coming out from splitting!!
global progress
progress.setActivity("HSR: Newell", len(facelist))
+ #progress.setQuiet(True)
+
while len(facelist):
+ debug("\n----------------------\n")
+ debug("len(facelits): %d\n" % len(facelist))
P = facelist[0]
- pSign = 1
- if P.sel == 0:
- pSign = -1
+ pSign = sign(P.normal[2])
+
+ # We can discard faces parallel to the view vector
+ if P.normal[2] == 0:
+ facelist.remove(P)
+ continue
+
+ split_done = 0
+ face_marked = 0
for Q in facelist[1:]:
debug("Q.smooth: " + str(Q.smooth) + "\n")
debug("\n")
- qSign = 1
- if Q.sel == 0:
- qSign = -1
-
- # We need to test only those Qs whose furthest vertex
+ qSign = sign(Q.normal[2])
+ # TODO: check also if Q is parallel??
+
+ # Test 0: We need to test only those Qs whose furthest vertex
# is closer to the observer than the closest vertex of P.
zP = [v.co[2] for v in P.v]
zQ = [v.co[2] for v in Q.v]
- ZOverlap = min(zP) < max(zQ)
+ notZOverlap = min(zP) > max(zQ)+EPS
- if not ZOverlap:
- if not Q.smooth:
- # We can safely print P
+ if notZOverlap:
+ debug("\nTest 0\n")
+ debug("NOT Z OVERLAP!\n")
+ if Q.smooth == 0:
+ # If Q is not marked then we can safely print P
break
else:
+ debug("met a marked face\n")
continue
+
# Test 1: X extent overlapping
xP = [v.co[0] for v in P.v]
xQ = [v.co[0] for v in Q.v]
- notXOverlap = (max(xP) < min(xQ)) or (max(xQ) < min(xP))
+ #notXOverlap = (max(xP) <= min(xQ)) or (max(xQ) <= min(xP))
+ notXOverlap = (min(xQ) >= max(xP)-EPS) or (min(xP) >= max(xQ)-EPS)
if notXOverlap:
+ debug("\nTest 1\n")
+ debug("NOT X OVERLAP!\n")
continue
+
# Test 2: Y extent Overlapping
yP = [v.co[1] for v in P.v]
yQ = [v.co[1] for v in Q.v]
- notYOverlap = (max(yP) < min(yQ)) or (max(yQ) < min(yP))
+ #notYOverlap = (max(yP) <= min(yQ)) or (max(yQ) <= min(yP))
+ notYOverlap = (min(yQ) >= max(yP)-EPS) or (min(yP) >= max(yQ)-EPS)
if notYOverlap:
+ debug("\nTest 2\n")
+ debug("NOT Y OVERLAP!\n")
continue
n = 0
for Pi in P:
d = qSign * Distance(Vector(Pi), Q)
- if d < EPS:
+ if d <= EPS:
n += 1
pVerticesBehindPlaneQ = (n == len(P))
n = 0
for Qi in Q:
d = pSign * Distance(Vector(Qi), P)
- if d >= EPS:
+ if d >= -EPS:
n += 1
qVerticesInFrontPlaneP = (n == len(Q))
debug("Q IN FRONT OF P!\n")
continue
- # Test 5: Line Intersections... TODO
+ # Test 5: Check if projections of polygons effectively overlap,
+ # in previous tests we checked only bounding boxes.
- # We do not know if P obscures Q.
+ if not projectionsOverlap(P, Q):
+ debug("\nTest 5\n")
+ debug("Projections do not overlap!\n")
+ continue
+
+ # We still can't say if P obscures Q.
+
+ # But if Q is marked we do a face-split trying to resolve a
+ # difficulty (maybe a visibility cycle).
if Q.smooth == 1:
- # Split P or Q, TODO
+ # Split P or Q
+ debug("Possibly a cycle detected!\n")
debug("Split here!!\n")
- continue
+ facelist = facesplit(P, Q, facelist, nmesh)
+ split_done = 1
+ break
# The question now is: Does Q obscure P?
+
# Test 3bis: Q vertices are all behind the plane of P
n = 0
for Qi in Q:
d = pSign * Distance(Vector(Qi), P)
- if d < EPS:
+ if d <= EPS:
n += 1
qVerticesBehindPlaneP = (n == len(Q))
+ if qVerticesBehindPlaneP:
+ debug("\nTest 3bis\n")
+ debug("Q BEHIND P!\n")
+
# Test 4bis: P vertices in front of the plane of Q
n = 0
for Pi in P:
d = qSign * Distance(Vector(Pi), Q)
- if d >= EPS:
+ if d >= -EPS:
n += 1
pVerticesInFrontPlaneQ = (n == len(P))
+ if pVerticesInFrontPlaneQ:
+ debug("\nTest 4bis\n")
+ debug("P IN FRONT OF Q!\n")
- """
- import intersection
-
+
+ # We don't even know if Q does obscure P, so they should
+ # intersect each other, split one of them in two parts.
if not qVerticesBehindPlaneP and not pVerticesInFrontPlaneQ:
- # Split P or Q, TODO
- print "Test 3bis or 4bis failed"
- print "Split here!!2\n"
-
- newfaces = intersection.splitOn(nmesh, P, Q, 0)
- facelist.remove(Q)
- for nf in newfaces:
- if nf:
- nf.col = Q.col
- facelist.append(nf)
-
- break
-
- # We do not know
- if Q.smooth:
- # split P or Q
- print "Split here!!\n"
- newfaces = intersection.splitOn(nmesh, P, Q, 0)
- facelist.remove(Q)
- for nf in newfaces:
- if nf:
- nf.col = Q.col
- facelist.append(nf)
-
- break
- """
-
- Q.smooth = 1
+ debug("\nSimple Intersection?\n")
+ debug("Test 3bis or 4bis failed\n")
+ debug("Split here!!2\n")
+
+ facelist = facesplit(P, Q, facelist, nmesh)
+ split_done = 1
+ break
+
facelist.remove(Q)
facelist.insert(0, Q)
+ Q.smooth = 1
+ face_marked = 1
+ debug("Q marked!\n")
+ break
# Write P!
- facelist.remove(P)
- maplist.append(P)
+ if split_done == 0 and face_marked == 0:
+ facelist.remove(P)
+ maplist.append(P)
- progress.update()
+ progress.update()
+
+ if facelist == None:
+ maplist = [P, Q]
+ print [v.co for v in P]
+ print [v.co for v in Q]
+ break
+
+ # end of while len(facelist)
+
-
nmesh.faces = maplist
- for f in nmesh.faces:
- f.sel = 1
nmesh.update()
+
def _doHiddenSurfaceRemoval(self, mesh):
"""Do HSR for the given mesh.
"""
return
if config.polygons['HSR'] == 'PAINTER':
- print "\n\nUsing the Painter algorithm for HSR.\n"
+ print "\nUsing the Painter algorithm for HSR."
self.__simpleDepthSort(mesh)
elif config.polygons['HSR'] == 'NEWELL':
- print "\n\nUsing the Newell's algorithm for HSR.\n"
+ print "\nUsing the Newell's algorithm for HSR."
self.__newellDepthSort(mesh)
projects / vrm.git / blobdiff