Set the field of view in degrees.

        Parameters
        -------------
        values : (2,) float
          Size of FOV to set in degrees
771764
def fov(self, values):
        
        if values is None:
            self._fov = None
        else:
            values = np.asanyarray(values, dtype=np.float64)
            if values.shape != (2,):
                raise ValueError('focal length must be (2,) int')
            # assign passed values to FOV
            self._fov = values
            # fov overrides focal
            self._focal = None
771463
def set_white_point(self, white_point, point2=None):
        """"""
        if isinstance(white_point, float) and isinstance(point2, float):
            white_point = (white_point, point2)
        self.white_point = white_point
1135460
public void setUVs(float u, float v, float U, float V)
	{
		minU = u;
		minV = v;
		maxU = U;
		maxV = V;
	}
452847
def set_lens(focal_length, frame_height = 24.0)
      @fov = 2.0 * Math.rad_to_deg(Math.atan(frame_height / (focal_length * 2.0)))
      update_projection_matrix
    end
463586
def set_perspective(self, fov, aspect, near, far):
        
        self.matrix = transforms.perspective(fov, aspect, near, far)
1354423
def set_coords(self, x=0, y=0, z=0, t=0):
        
        self.coords = {}
        self.coords['x'] = x
        self.coords['y'] = y
        self.coords['z'] = z
        self.coords['t'] = t
1131620
public void set(float sx, float sy, float ex, float ey) {
		super.pointsDirty = true;
		start.set(sx, sy);
		end.set(ex, ey);
		float dx = (ex - sx);
		float dy = (ey - sy);
		vec.set(dx,dy);
		
		lenSquared = (dx * dx) + (dy * dy);
	}
618541
def set(self, varname, value, idx=0, units=None):
        ''''''
        if not varname in self.mapping.vars:
            raise fgFDMError('Unknown variable %s' % varname)
        if idx >= self.mapping.vars[varname].arraylength:
            raise fgFDMError('index of %s beyond end of array idx=%u arraylength=%u' % (
                varname, idx, self.mapping.vars[varname].arraylength))
        if units:
            value = self.convert(value, units, self.mapping.vars[varname].units)
        # avoid range errors when packing into 4 byte floats
        if math.isinf(value) or math.isnan(value) or math.fabs(value) > 3.4e38:
            value = 0
        self.values[self.mapping.vars[varname].index + idx] = value
1016211
def Y(self, value):
        
        if isinstance(value, (int, float,
                              long, types.NoneType)):
            self._y = value
181265
def set_viewup(self, vector):
        
        if isinstance(vector, np.ndarray):
            if vector.ndim != 1:
                vector = vector.ravel()
        self.camera.SetViewUp(vector)
        self._render()
923096
public void setValue(float angle, float x, float y, float z) {
        set(angle, x, y, z);
    }
1301235
def set_float_info(self, field, data):
        
        _check_call(_LIB.XGDMatrixSetFloatInfo(self.handle,
                                               c_str(field),
                                               c_array(ctypes.c_float, data),
                                               len(data)))
1009837
def _set_anchor(self, value):
        
        pX, pY = self.anchor
        x, y = value
        dX = x - pX
        dY = y - pY
        self.moveBy((dX, dY))
140394
def __vCmdSetCamAperture(self, args):
        ''''''
        if len(args) == 1:
            for cam in self.camera_list:
                cam.boSetAperture(int(args[0]))
        elif len(args) == 2:
            cam = self.camera_list[int(args[1])]
            cam.boSetAperture(int(args[0]))
        else:
            print ("Usage: setCamAperture APERTURE [CAMNUMBER], APERTURE is value x10")
66634
def vertices(self, values):
        
        self._data['vertices'] = np.asanyarray(values,
                                               order='C',
                                               dtype=np.float64)
738739
def face_normals(self, values):
        
        if values is not None:
            # make sure face normals are C- contiguous float
            values = np.asanyarray(values,
                                   order='C',
                                   dtype=np.float64)

            # check if any values are larger than tol.merge
            # this check is equivalent to but 25% faster than:
            # `np.abs(values) > tol.merge`
            nonzero = np.logical_or(values > tol.merge,
                                    values < -tol.merge)

            # don't set the normals if they are all zero
            if not nonzero.any():
                log.warning('face_normals all zero, ignoring!')
                return

            # make sure the first few normals match the first few triangles
            check, valid = triangles.normals(
                self.vertices.view(np.ndarray)[self.faces[:20]])
            compare = np.zeros((len(valid), 3))
            compare[valid] = check

            if not np.allclose(compare, values[:20]):
                log.warning('face_normals didn\'t match triangles, ignoring!')
                return

        self._cache['face_normals'] = values
1277773
public void setPixels(int view , List<Point2D_F64> pixelsInView ) {
		if( pixelsInView.size() != pixels.numCols )
			throw new IllegalArgumentException("Pixel count must be constant and match "+pixels.numCols);

		int row = view*2;
		for (int i = 0; i < pixelsInView.size(); i++) {
			Point2D_F64 p = pixelsInView.get(i);
			pixels.set(row,i,p.x);
			pixels.set(row+1,i,p.y);
			pixelScale = Math.max(Math.abs(p.x),Math.abs(p.y));
		}
	}