Returns the z-coordinate of a vertex normal.

@param vertex the vertex index
@return the z coordinate
508477
public float getNormalZ(int vertex) {
        if (!hasNormals()) {
            throw new IllegalStateException("mesh has no normals");
        }
        
        checkVertexIndexBounds(vertex);
        
        return m_normals.getFloat((vertex * 3 + 2) * SIZEOF_FLOAT);
    }
578518
public void vertex(Vector3D v) {
        MODE = LINES_3D;
        this.x.add(v.getX());
        this.y.add(v.getY());
        this.z.add(v.getZ());
        colors.add(this.strokeColor);
        calcG();
    }
296735
public function getIndexVertex(Vertex $vertex)
    {
        $id = array_search($vertex, $this->vertices, true);
        if ($id === false) {
            throw new OutOfBoundsException('Given vertex does NOT exist');
        }
        return $id;
    }
590563
public Model deleteVertex(Vertex vertex) {
    edges.removeIf(edge -> vertex.equals(edge.getSourceVertex()) || vertex.equals(edge.getTargetVertex()));
    vertices.remove(vertex);
    return this;
  }
292462
def Log(input_vertex: vertex_constructor_param_types, label: Optional[str]=None) -> Vertex:
    
    return Double(context.jvm_view().LogVertex, label, cast_to_double_vertex(input_vertex))
333605
public float getTangentY(int vertex) {
        if (!hasTangentsAndBitangents()) {
            throw new IllegalStateException("mesh has no bitangents");
        }
        
        checkVertexIndexBounds(vertex);
        
        return m_tangents.getFloat((vertex * 3 + 1) * SIZEOF_FLOAT);
    }
1005143
public int getAttributeSize(int index) {
        final VertexAttribute attribute = getAttribute(index);
        if (attribute == null) {
            return -1;
        }
        return attribute.getSize();
    }
283785
public Object remove(Object vertex) {
        VertexMetadata vm = (VertexMetadata) vertices.get(vertex);
        if (vm == null) {
            return null;
        }
        vertices.remove(vertex);
        vertexModCount++;
        int index = vm.index;
        for (int row = 0; row < capacity; row++) {
            edges[row][index] = null;
            edges[index][row] = null;
            edgeModCount++;
        }
        edgesArr = null;
        freeList.add(index);
        return vertex;
    }
957826
def degree(self, vertex):
        
        try:
            return len(self.vertices[vertex])
        except KeyError:
            raise GraphInsertError("Vertex %s doesn't exist." % (vertex,))
434408
def normal
      vec1 = self.vertices[1] - self.vertices[0]
      vec2 = self.vertices[2] - self.vertices[0]
      return (vec1.cross(vec2).normalize)
    end
84636
def vertex_normals(vertices, faces):
    """"""

    def normalize_v3(arr):
        ''' Normalize a numpy array of 3 component vectors shape=(n,3) '''
        lens = np.sqrt(arr[:, 0]**2 + arr[:, 1]**2 + arr[:, 2]**2)
        arr /= lens[:, np.newaxis]

    tris = vertices[faces]
    facenorms = np.cross(tris[::, 1] - tris[::, 0], tris[::, 2] - tris[::, 0])
    normalize_v3(facenorms)

    norm = np.zeros(vertices.shape, dtype=vertices.dtype)
    norm[faces[:, 0]] += facenorms
    norm[faces[:, 1]] += facenorms
    norm[faces[:, 2]] += facenorms
    normalize_v3(norm)
    return norm
877164
public String getAttributeName(int index) {
        final VertexAttribute attribute = getAttribute(index);
        if (attribute == null) {
            return null;
        }
        return attribute.getName();
    }
529397
public static VertexData generateCone(float radius, float height) {
        final VertexData destination = new VertexData();
        final VertexAttribute positionsAttribute = new VertexAttribute("positions", DataType.FLOAT, 3);
        destination.addAttribute(0, positionsAttribute);
        final TFloatList positions = new TFloatArrayList();
        final VertexAttribute normalsAttribute = new VertexAttribute("normals", DataType.FLOAT, 3);
        destination.addAttribute(1, normalsAttribute);
        final TFloatList normals = new TFloatArrayList();
        final TIntList indices = destination.getIndices();
        // Generate the mesh
        generateCone(positions, normals, indices, radius, height);
        // Put the mesh in the vertex data
        positionsAttribute.setData(positions);
        normalsAttribute.setData(normals);
        return destination;
    }
311596
public float getTangentZ(int vertex) {
        if (!hasTangentsAndBitangents()) {
            throw new IllegalStateException("mesh has no tangents");
        }
        
        checkVertexIndexBounds(vertex);
        
        return m_tangents.getFloat((vertex * 3 + 2) * SIZEOF_FLOAT);
    }
694292
public float getPositionZ(int vertex) {
        if (!hasPositions()) {
            throw new IllegalStateException("mesh has no positions");
        }
        
        checkVertexIndexBounds(vertex);
        
        return m_vertices.getFloat((vertex * 3 + 2) * SIZEOF_FLOAT);
    }
1308162
def vertex_normals(self, values):
        
        if values is not None:
            values = np.asanyarray(values,
                                   order='C',
                                   dtype=np.float64)
            if values.shape == self.vertices.shape:
                self._cache['vertex_normals'] = values
381265
public float getNormalY(int vertex) {
        if (!hasNormals()) {
            throw new IllegalStateException("mesh has no normals");
        }
        
        checkVertexIndexBounds(vertex);
        
        return m_normals.getFloat((vertex * 3 + 1) * SIZEOF_FLOAT);
    }