def Farthest_Point_Sampling(mesh_name,n):
"""
add the new farest point to set and print n out of all of mesh
:param mesh_name:
:param n:
:return:
"""
mesh = read(mesh_name + ".ply")
v, f = (np.array(mesh.points), np.array(mesh.cells_dict['triangle'], dtype=np.int32))
geodesics_dist = gdist.local_gdist_matrix(v.astype(np.float64), f.astype(np.int32))
mesh = Mesh(v=v,f=f)
mesh.render_pointcloud(scalar_function=mesh.gaussianCurvature())
s=[]
s.append(np.random.randint(0, len(v)))
while (len(s)!=n):
max_dist = 0
selected_v = None
for i,v_i in enumerate(v):
min_by_s = np.inf
for s_i in s: #get minimum ovver all s_i
dist = geodesics_dist[s_i][v_i]
if dist < min_by_s:
min_by_s = dist
if min_by_s > max_dist:
max_dist = min_by_s
selected_v = v_i
v = np.delete(v,selected_v) #dont iterate v over this node anymore
s.append(selected_v)
f_new=gen_f(s)
mesh = Mesh(v=v[np.array(s)], f=f_new)
mesh.render_pointcloud(scalar_function=mesh.gaussianCurvature())
def __init__(self, engine, editorMode = False):
self.engine = engine
self.boardWidth = 4.0
self.boardLength = 12.0
self.beatsPerBoard = 5.0
self.strings = 5
self.fretWeight = [0.0] * self.strings
self.fretActivity = [0.0] * self.strings
self.fretColors = Theme.fretColors
self.playedNotes = []
self.editorMode = editorMode
self.selectedString = 0
self.time = 0.0
self.pickStartPos = 0
self.leftyMode = False
self.currentBpm = 50.0
self.currentPeriod = 60000.0 / self.currentBpm
self.targetBpm = self.currentBpm
self.lastBpmChange = -1.0
self.baseBeat = 0.0
self.setBPM(self.currentBpm)
self.vertexCache = numpy.empty((8 * 4096, 3), numpy.float32)
self.colorCache = numpy.empty((8 * 4096, 4), numpy.float32)
engine.resource.load(self, "noteMesh", lambda: Mesh(engine.resource.fileName("note.dae")))
engine.resource.load(self, "keyMesh", lambda: Mesh(engine.resource.fileName("key.dae")))
engine.loadSvgDrawing(self, "glowDrawing", "glow.png")
engine.loadSvgDrawing(self, "neckDrawing", "neck.png")
engine.loadSvgDrawing(self, "stringDrawing", "string.png")
engine.loadSvgDrawing(self, "barDrawing", "bar.png")
engine.loadSvgDrawing(self, "noteDrawing", "note.png")
def __init__(self,
engine,
prompt="",
selectedSong=None,
selectedLibrary=None):
self.prompt = prompt
self.engine = engine
self.time = 0
self.accepted = False
self.selectedIndex = 0
self.camera = Camera()
self.cassetteHeight = .8
self.cassetteWidth = 4.0
self.libraryHeight = 1.2
self.libraryWidth = 4.0
self.itemAngles = None
self.itemLabels = None
self.selectedOffset = 0.0
self.cameraOffset = 0.0
self.selectedItem = None
self.song = None
self.songCountdown = 1024
self.songLoader = None
self.initialItem = selectedSong
self.library = selectedLibrary
self.searchText = ""
# Use the default library if this one doesn't exist
if not self.library or not os.path.isdir(
self.engine.resource.fileName(self.library)):
self.library = Song.DEFAULT_LIBRARY
self.loadCollection()
self.engine.resource.load(
self,
"cassette",
lambda: Mesh(self.engine.resource.fileName("cassette.dae")),
synch=True)
self.engine.resource.load(
self,
"label",
lambda: Mesh(self.engine.resource.fileName("label.dae")),
synch=True)
self.engine.resource.load(
self,
"libraryMesh",
lambda: Mesh(self.engine.resource.fileName("library.dae")),
synch=True)
self.engine.resource.load(
self,
"libraryLabel",
lambda: Mesh(self.engine.resource.fileName("library_label.dae")),
synch=True)
self.engine.loadSvgDrawing(self, "background", "cassette.svg")
def deflectomotery(objectName, imgDir):
Img = Image(imgDir, objectName)
Gradient_V = setGrad(Img.imgVSet, 3.8)
Gradient_H = setGrad(Img.imgHSet, 3.8)
#cv2.imwrite(os.path.join(imgDir, 'GradV.png'), np.array(Gradient_V * 255, dtype=np.uint8))
#cv2.imwrite(os.path.join(imgDir, 'GradH.png'), np.array(Gradient_H * 255, dtype=np.uint8))
N = np.zeros((Img.height, Img.width, 3), dtype=Img.PRECISION_IMG)
N[..., 0] = -Gradient_V / np.sqrt(np.square(Gradient_V) + np.square(Gradient_H) + 1)
N[..., 1] = -Gradient_H / np.sqrt(np.square(Gradient_V) + np.square(Gradient_H) + 1)
N[..., 2] = 1 / np.sqrt(np.square(Gradient_V) + np.square(Gradient_H) + 1)
# crop valid region
Ncrop = N[Img.mask[0]:Img.mask[2], Img.mask[1]:Img.mask[3]]
A = Img.A[Img.mask[0]:Img.mask[2], Img.mask[1]:Img.mask[3]]
[newHeight, newWidth, _] = A.shape
Nfname = os.path.join(imgDir, 'normal.png')
# xyz to zyx because of OPENCV BGR order
cv2.imwrite(Nfname, cv2.cvtColor(np.array((Ncrop + 1) / 2.0 * 255, dtype=np.uint8), cv2.COLOR_RGB2BGR))
mesh = Mesh(objectName, newHeight, newWidth, Img.mask)
mesh.setNormal(N)
mesh.setDepth()
mesh.setTexture(A)
mesh.exportOBJ(imgDir, True)
def Calc_Num_Dets(self):
self.Dets_Num = Mesh(self.N, "Det", "Num")
for n in range(self.N):
self.Dets_Num[n] = None
det = self.Calc_Num_Det(self.ts[n])
if (det.__class__.__name__ == "float"):
self.Dets_Num[n] = Vector([self.ts[n], det])
def Calc_Ana_Dets(self):
self.Dets_Ana = Mesh(self.N, "Det", "Ana")
for n in range(self.N):
self.Dets_Ana[n] = None
det = self.Det(self.ts[n])
if (det != None):
self.Dets_Ana[n] = Vector([self.ts[n], det])
def Calc_Ana_Function(self,function):
attr=function
if (not self.Curve_Type_Has_Analytical(function)):
print "No analytical method:",attr
return None
if (not hasattr(self,attr)):
print "No class attribute:",attr
return None
method=getattr(self,attr)
mesh=Mesh(self.N,function,"Ana")
errors=0
for n in range( self.N ):
mesh[n]=None
value=None
try:
value=method( self.ts[n] )
except:
errors+=1
if (value!=None):
mesh[n]=Vector([ self.ts[n],value ])
return mesh
def BuildSpace(self):
# Generating the Mesh
Params = {'Nelems': self.Nelems, 'a': self.a, 'b': self.b}
mesh = Mesh(**Params)
# Retreiving the mesh ends up with a tuple with the Grid and its iterator
(self.Grid, Grid_itr) = mesh.get_Mesh()
print self.Grid
i = 0
# Generate the elements over the Grid
NodesPerElem = len(self.Shape_Funct.getSF_Names())
for k in Grid_itr:
Segment_Props = {'k': i, 'Interval': self.Grid[k:k + NodesPerElem]}
self.FE.insert(i, Finite_Element(**Segment_Props))
i = i + 1
# Calculate functionals
for Element in self.FE:
for funct in self.Shape_Funct.getSF_Names():
Element.Functional(self.Shape_Funct.getFunctional(funct))(
Element.interval)
# For each element assign p(x), q(x) and f(x)
for Element in self.FE:
Element.p_x = self.p_x
Element.q_x = self.q_x
Element.f_x = self.f_x
# Creating the local symbolic Matrices and evaluating the numerical integrals over the interval
for Element in self.FE:
Element.create_stiff_local_Sym()
Element.create_nodal_forces_local_Sym()
Element.solve_stiff_local()
Element.solve_forces_local()
def Render(mesh=Mesh(), textureImg=None, textureHandle=None, angle=0.0):
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glLoadIdentity()
glPushMatrix()
# gluLookAt(0.0, 0.0, mesh.radius,
# 0.0, 0.0, 0.0,
# 0.0, mesh.radius, 0.0)
# gluLookAt(0.0, 0.0, 100,
# 0.0, 0.0, 0.0,
# 0.0, 100, 0.0)
# glPushMatrix()
glRotatef(-180, 1.0, 0.0, 0.0)
glRotatef(angle, 0.0, 1.0, 0.0)
glTranslatef(-mesh.center[0], -mesh.center[1], -mesh.center[2])
#
# glPopMatrix()
# textureImg.
# glColor3f(1.0, 0.0, 0.5)
glBindTexture(GL_TEXTURE_2D, textureHandle)
# DrawPlane()
#DrawTriangle()
DrawMesh(mesh)
glPopMatrix()
def Calc_Num_v2s(self):
self.v2s_Num = Mesh(self.N, "v2", "Num")
for n in range(self.N):
self.v2s_Num[n] = None
v2 = self.Calc_Num_v2(self.ts[n])
if (v2.__class__.__name__ == "float"):
self.v2s_Num[n] = Vector([self.ts[n], v2])
def Calc_Ana_v2s(self):
self.v2s_Ana = Mesh(self.N, "v2", "Ana")
for n in range(self.N):
self.v2s_Ana[n] = None
v2 = self.v2(self.ts[n])
if (v2.__class__.__name__ == "float"):
self.v2s_Ana[n] = Vector([self.ts[n], v2])
def _gen_space_btn_clicked(self):
width = int(self._width.text())
height = int(self._height.text())
if self._canvas:
self._canvas.close()
self._mesh = Mesh(width, height, PROB)
self._canvas = Canvas(self.get_canvas__geometry(), self._mesh)
self._canvas.show()
def Calc_Ana_Ss(self):
self.S1 = self.S(self.t1)
self.Ss_Ana = Mesh(self.N, "S", "Ana")
for n in range(self.N):
self.Ss_Ana[n] = None
s = self.S(self.ts[n]) - self.S1
if (s.__class__.__name__ == "float"):
self.Ss_Ana[n] = Vector([self.ts[n], s])
def Calc_Num_dPhis(self):
self.dPhis_Num = Mesh(self.N, "dPhi", "Num")
for n in range(self.N):
dphi = self.Calc_Num_dPhi(self.ts[n])
v = None
if (dphi):
v = Vector([self.ts[n], dphi])
self.dPhis_Num[n] = v
def Calc_Num_Kappas(self):
self.Kappas_Num = Mesh(self.N, "Kappa", "Num")
for n in range(self.N):
kappa = self.Calc_Num_Kappa(self.ts[n])
v = None
if (kappa):
v = Vector([self.ts[n], kappa])
self.Kappas_Num[n] = v
def Calc_Num_dRhos(self):
self.dRhos_Num = Mesh(self.N, "dRho", "Num")
for n in range(self.N):
drho = self.Calc_Num_dRho(self.ts[n])
v = None
if (drho):
v = Vector([self.ts[n], drho])
self.dRhos_Num[n] = v
def Calc_Ana_Phis(self):
self.Phis_Ana = Mesh(self.N, "Phi", "Ana")
for n in range(self.N):
phi = self.Phi(self.ts[n])
v = None
if (phi):
v = Vector([self.ts[n], phi])
self.Phis_Ana[n] = v
def Calc_Ana_Kappas(self):
self.Kappas_Ana = Mesh(self.N, "Kappa", "Ana")
for n in range(self.N):
kappa = self.Kappa(self.ts[n])
v = None
if (kappa):
v = Vector([self.ts[n], kappa])
self.Kappas_Ana[n] = v
def Calc_Ana_Rhos(self):
self.Rhos_Ana = Mesh(self.N, "Rho", "Ana")
for n in range(self.N):
v = None
rho = self.Rho(self.ts[n])
if (rho):
v = Vector([self.ts[n], rho])
self.Rhos_Ana[n] = v
def Calc_Num_Psis(self):
self.Psis_Num = Mesh(self.N, "Psi", "Num")
for n in range(self.N):
p = None
psi = self.Calc_Num_Psi(self.ts[n])
if (psi):
p = Vector([self.ts[n], psi])
self.Psis_Num[n] = p
def Calc_Ana_Psis(self):
self.Psis_Ana = Mesh(self.N, "Psi", "Ana")
for n in range(self.N):
psi = self.Psi(self.ts[n])
v = None
if (psi):
v = Vector([self.ts[n], psi])
self.Psis_Ana[n] = v
def clear_btn_clicked(self):
width = int(self._width.text())
height = int(self._height.text())
prob_rule4 = int(self._prob_rule4.text())
self._mesh = Mesh(width, height, prob_rule4)
self._canvas.close()
self._canvas = Canvas(self.get_canvas__geometry(), self._mesh)
self._canvas.show()
self._canvas.repaint()
def Calc_Num_Rhos(self):
self.Rhos_Num = Mesh(self.N, "Rho", "Num")
for n in range(self.N):
v = None
rho = self.Calc_Num_Rho(self.ts[n])
if (rho.__class__.__name__ == "float"):
v = Vector([self.ts[n], rho])
self.Rhos_Num[n] = v
def Calc_Num_Phis(self):
self.Phis_Num = Mesh(self.N, "Phi", "Num")
for n in range(self.N):
p = None
phi = self.Calc_Num_Phi(self.ts[n])
if (phi):
p = Vector([self.ts[n], phi])
self.Phis_Num[n] = p
def Calc_Mesh_Type_Num(self,mtype):
mesh=Mesh(self.N,mtype,"Num")
method=getattr(self,"Calc_Num_"+mtype)
for n in range( self.N ):
mesh[n]=method( self.ts[n] )
mesh.__Canvas__=self.__Canvas__
return mesh
def Mesh(self, t1, t2, N, n=0):
dt = (t2 - t1) / (1.0 * (N - 1))
mesh = Mesh(N)
t = t1
for i in range(N):
mesh[i] = Vector([t, self.df(t, n)])
t += dt
return mesh
def __init__(self, file_name):
global active_camera
self.models = None
self.cameras = None
self.lights = None
self.active_camera = active_camera
# shared resources
self.textures = {} # name -> tex lookup
self.shaders = {} # name -> tex lookup
self.meshes = {} # name -> tex lookup
with open(file_name, "r") as fp:
data = json.load(fp)
# models
self.models = {name: Model(m) for (name, m) in data["models"].items()}
for model in self.models.values():
vert_file = model.io['shader']['vert']
frag_file = model.io['shader']['frag']
shader_name = vert_file.split('.')[0]
shader = ResourceManager.get_shader(shader_name)
if not shader:
shader = Shader(vert_file, frag_file)
ResourceManager.add_shader(shader_name, shader)
model.shader = shader
mesh_name = model.io['mesh'] # contains relative path string
mesh = ResourceManager.get_mesh(mesh_name)
if not mesh:
mesh = Mesh(mesh_name)
ResourceManager.add_mesh(mesh_name, mesh)
model.mesh = mesh
tex_files = model.io['textures']
for (layer, tex_file) in tex_files.items():
tex = ResourceManager.get_texture(tex_file)
if not tex:
tex = Texture(tex_file)
ResourceManager.add_texture(tex_file, tex)
model.textures[layer] = tex
# cameras, set first camera to active
self.cameras = {
name: Camera(c)
for (name, c) in data["cameras"].items()
}
if len(self.cameras) > 0:
# get first items value
active_camera = next(iter(self.cameras.items()))[1]
logging.warn('camera needs to set shader uniforms')
# lights
self.lights = {name: Light(l) for (name, l) in data["lights"].items()}
logging.warn('light needs to set shader uniforms')
def load_mesh(path):
with open(path, 'r') as f:
width, height = f.readline().split(' ')
mesh = Mesh(int(width), int(height))
points = mesh.get_points()
for line in f.read().splitlines():
x, y, phase, id = line.split(' ')
points[int(x)][int(y)].id = int(id)
points[int(x)][int(y)].phase = int(phase)
return mesh
def getMesh(self):
mesh = Mesh()
self.readPoints(mesh)
self.readElems(mesh)
self.readSides(mesh)
return mesh
def Calc_Rs(self):
self.Rs = Mesh(self.N, "R", "")
err = 0
for n in range(self.N):
try:
self.Rs[n] = self.R(self.ts[n])
except ValueError:
err = 1
return err
