def _sample_ray(ray, npoints, field): """ Private function that uses a ray object for calculating the field values that will be the y-axis values in a LinePlot object. Parameters ---------- ray : YTOrthoRay, YTRay, or LightRay Ray object from which to sample field values npoints : int The number of points to sample field : str or field tuple The name of the field to sample """ start_point = ray.start_point end_point = ray.end_point sample_dr = (end_point - start_point) / (npoints - 1) sample_points = [np.arange(npoints) * sample_dr[i] for i in range(3)] sample_points = uvstack(sample_points).T + start_point ray_coordinates = uvstack([ray[d] for d in "xyz"]).T ray_dds = uvstack([ray["d" + d] for d in "xyz"]).T ray_field = ray[field] field_values = ray.ds.arr(np.zeros(npoints), ray_field.units) for i, sample_point in enumerate(sample_points): ray_contains = (sample_point >= (ray_coordinates - ray_dds / 2)) & ( sample_point <= (ray_coordinates + ray_dds / 2)) ray_contains = ray_contains.all(axis=-1) # use argmax to find the first nonzero index, sometimes there # are two indices if the sampling point happens to fall exactly at # a cell boundary field_values[i] = ray_field[np.argmax(ray_contains)] dr = np.sqrt((sample_dr**2).sum()) x = np.arange(npoints) / (npoints - 1) * (dr * npoints) return x, field_values
def test_numpy_wrappers(): a1 = YTArray([1, 2, 3], 'cm') a2 = YTArray([2, 3, 4, 5, 6], 'cm') a3 = YTArray([7, 8, 9, 10, 11], 'cm') catenate_answer = [1, 2, 3, 2, 3, 4, 5, 6] intersect_answer = [2, 3] union_answer = [1, 2, 3, 4, 5, 6] vstack_answer = [[2, 3, 4, 5, 6], [7, 8, 9, 10, 11]] assert_array_equal(YTArray(catenate_answer, 'cm'), uconcatenate((a1, a2))) assert_array_equal(catenate_answer, np.concatenate((a1, a2))) assert_array_equal(YTArray(intersect_answer, 'cm'), uintersect1d(a1, a2)) assert_array_equal(intersect_answer, np.intersect1d(a1, a2)) assert_array_equal(YTArray(union_answer, 'cm'), uunion1d(a1, a2)) assert_array_equal(union_answer, np.union1d(a1, a2)) assert_array_equal(YTArray(catenate_answer, 'cm'), uhstack([a1, a2])) assert_array_equal(catenate_answer, np.hstack([a1, a2])) assert_array_equal(YTArray(vstack_answer, 'cm'), uvstack([a2, a3])) assert_array_equal(vstack_answer, np.vstack([a2, a3])) assert_array_equal(YTArray(vstack_answer, 'cm'), ustack([a2, a3])) assert_array_equal(vstack_answer, np.stack([a2, a3]))
def _get_sampler_params(self, camera, render_source): # Enforce width[1] / width[0] = 2 * resolution[1] / resolution[0] # For stereo-type lens, images for left and right eye are pasted together, # so the resolution of single-eye image will be 50% of the whole one. camera.width[1] = camera.width[0] * ( 2.0 * camera.resolution[1] / camera.resolution[0] ) if self.disparity is None: self.disparity = 3.0 * camera.width[0] / camera.resolution[0] if render_source.zbuffer is not None: image = render_source.zbuffer.rgba else: image = self.new_image(camera) vectors_left, positions_left = self._get_positions_vectors( camera, -self.disparity ) vectors_right, positions_right = self._get_positions_vectors( camera, self.disparity ) uv = np.ones(3, dtype="float64") image = self.new_image(camera) vectors_comb = uvstack([vectors_left, vectors_right]) positions_comb = uvstack([positions_left, positions_right]) image.shape = (camera.resolution[0], camera.resolution[1], 4) vectors_comb.shape = (camera.resolution[0], camera.resolution[1], 3) positions_comb.shape = (camera.resolution[0], camera.resolution[1], 3) sampler_params = dict( vp_pos=positions_comb, vp_dir=vectors_comb, center=self.back_center, bounds=(0.0, 1.0, 0.0, 1.0), x_vec=uv, y_vec=uv, width=np.zeros(3, dtype="float64"), image=image, lens_type="stereo-perspective", ) return sampler_params
def _yield_coordinates(self, data_file): pn = "particle_position_%s" with h5py.File(data_file.filename, 'r') as f: units = parse_h5_attr(f[pn % "x"], "units") x, y, z = (self.ds.arr(f[pn % ax].value.astype("float64"), units) for ax in 'xyz') pos = uvstack([x, y, z]).T pos.convert_to_units('code_length') yield 'halos', pos
def _yield_coordinates(self, data_file): pn = "particle_position_%s" with h5py.File(data_file.filename, mode="r") as f: units = parse_h5_attr(f[pn % "x"], "units") x, y, z = (self.ds.arr(f[pn % ax][()].astype("float64"), units) for ax in "xyz") pos = uvstack([x, y, z]).T pos.convert_to_units("code_length") yield "halos", pos
def _yield_coordinates(self, data_file): with h5py.File(data_file.filename, "r") as f: for ptype in f.keys(): if "x" not in f[ptype].keys(): continue units = _get_position_array_units(ptype, f, "x") x, y, z = (self.ds.arr(_get_position_array(ptype, f, ax), units) for ax in "xyz") pos = uvstack([x, y, z]).T pos.convert_to_units("code_length") yield ptype, pos
def project_to_plane(self, camera, pos, res=None): if res is None: res = camera.resolution # Enforce width[1] / width[0] = 2 * resolution[1] / resolution[0] # For stereo-type lens, images for left and right eye are pasted together, # so the resolution of single-eye image will be 50% of the whole one. camera.width[1] = camera.width[0] * (2. * res[1] / res[0]) if self.disparity is None: self.disparity = 3. * camera.width[0] / camera.resolution[0] px_left, py_left, dz_left = self._get_px_py_dz(camera, pos, res, -self.disparity) px_right, py_right, dz_right = self._get_px_py_dz( camera, pos, res, self.disparity) px = uvstack([px_left, px_right]) py = uvstack([py_left, py_right]) dz = uvstack([dz_left, dz_right]) return px, py, dz