vertex

I've been playing with SceneKit, but I can't figure how to create a per vertex color geometry. So to be more precise, I would like to do this : http://openglbook.com/chapter-2-vertices-and-shapes.html Let me know if it's not clear Thanks. Pour info : sceneView = SCNView(frame: sceneContainer.bounds) sceneView.scene = SCNScene() sceneView.allowsCameraControl = true sceneView.autoenablesDefaultLighting = true sceneView.showsStatistics = true sceneView.backgroundColor = UIColor.darkGrayColor() self.sceneContainer.addSubview(sceneView) // Vertex let vertices: [SCNVector3] = [SCNVector3(0, 0, 0),

I have a THREE.PlaneGeometry , with ComputeFaceNormals() . I create two meshes using this geometry, with different rotations applied to them. I want to compute the two angles between the camera and the two meshes central face normal. It should be : vLocalCamera = vCamera.position - mesh1.position; mesh1.normal() . vLocalCamera = cos(angle); The problem is that I don't know how to get the mesh normal in world coordinate (from geometry and mesh rotation) with three.js API If you want to convert a face or vertex normal, normal , from local space to world space, you do it like so: var normalMatrix

As an extension and partial answer to my thread I wrote a simple algorithm that given a set of points(with xy coordinates) can form a non self-intersecting polygon. Claim: Given an arbitrary set of points with different coordinates it is always possible to construct a regular or irregular, non self-intersecting polygon. The algorithm: Assume there is a set V containing all the vertices 1) Sort all vertices in V by x-coordinate 2) Imagine a straight line (we'll call that "the divider") parallel to the x-axis which starting from the first node expands to infinity and divides/splits the vertices

I'm trying to get a clear idea of when I should be using indexed arrays of OpenGL vertices, drawn with gl[Multi]DrawElements and the like, versus when I should simply use contiguous arrays of vertices, drawn with gl[Multi]DrawArrays. ( Update: The consensus in the replies I got is that one should always be using indexed vertices.) I have gone back and forth on this issue several times, so I'm going to outline my current understanding, in the hopes someone can either tell me I'm now finally more or less correct, or else point out where my remaining misunderstandings are. Specifically, I have

i have numpy array in python which contains lots (10k+) of 3D vertex points (vectors with coordinates [x,y,z]). I need to calculate distance between all possible pairs of these points. it's easy to do using scipy: import scipy D = spdist.cdist(verts, verts) but i can't use this because of project policy on introducing new dependencies. So i came up with this naive code: def vert_dist(self, A, B): return ((B[0]-A[0])**2+(B[1]-A[1])**2+(B[2]-A[2])**2)**(1.0/2) # Pairwise distance between verts #Use SciPy, otherwise use fallback try: import scipy.spatial.distance as spdist D = spdist.cdist(verts,

I want to create a depth first search which I have been somewhat successful in. Here is my code so far (Except my constructor, note the Vertex and Edge classes only contain properties, nothing important to post here): private Stack<Vertex> workerStack = new Stack<Vertex>(); private List<Vertex> vertices = new List<Vertex>(); private List<Edge> edges = new List<Edge>(); private int numberOfVertices; private int numberOfClosedVertices; private int visitNumber = 1; private void StartSearch() { // Make sure to visit all vertices while (numberOfClosedVertices < numberOfVertices && workerStack.Count