def pupilCoordsFromPixelCoords(self, xPix, yPix, chipName, includeDistortion=True): """ Convert pixel coordinates into pupil coordinates Parameters ---------- xPix is the x pixel coordinate of the point. Can be either a float or a numpy array. Defined in the Camera team system (not the DM system). yPix is the y pixel coordinate of the point. Can be either a float or a numpy array. Defined in the Camera team system (not the DM system). chipName is the name of the chip(s) on which the pixel coordinates are defined. This can be a list (in which case there should be one chip name for each (xPix, yPix) coordinate pair), or a single value (in which case, all of the (xPix, yPix) points will be reckoned on that chip). includeDistortion is a boolean. If True (default), then this method will expect the true pixel coordinates with optical distortion included. If False, this method will expect TAN_PIXEL coordinates, which are the pixel coordinates with estimated optical distortion removed. See the documentation in afw.cameraGeom for more details. Returns ------- a 2-D numpy array in which the first row is the x pupil coordinate and the second row is the y pupil coordinate (both in radians) """ dm_xPix = yPix if isinstance(chipName, list) or isinstance(chipName, np.ndarray): dm_yPix = np.zeros(len(xPix)) for ix, (det_name, xx) in enumerate(zip(chipName, xPix)): came_center_pix = self.getCenterPixel(det_name) dm_yPix[ix] = 2.0 * cam_center_pix.getX() - xPix[ix] else: cam_center_pix = self.getCenterPixel(chipName) dm_yPix = 2.0 * cam_center_pix.getX() - xPix return coordUtils.pupilCoordsFromPixelCoords( dm_xPix, dm_yPix, chipName, camera=coordUtils.lsst_camera(), includeDistortion=includeDistortion)
def testContainsPupilCoordinates(self): """ Test whether or not the method containsRaDec correctly identifies RA and Dec that fall inside and outside the detector """ photParams = PhotometricParameters() gsdet = GalSimDetector(self.camera[0], self.camera, \ self.obs, self.epoch, photParams=photParams) xxList = [gsdet.xMinPix, gsdet.xMaxPix] yyList = [gsdet.yMinPix, gsdet.yMaxPix] dxList = [-1.0, 1.0] dyList = [-1.0, 1.0] xPixList = [] yPixList = [] correctAnswer = [] for xx, yy, dx, dy in zip(xxList, yyList, dxList, dyList): xPixList.append(xx) yPixList.append(yy) correctAnswer.append(True) xPixList.append(xx+dx) yPixList.append(yy) correctAnswer.append(False) xPixList.append(xx) yPixList.append(yy+dy) correctAnswer.append(False) nameList = [gsdet.name]*len(xPixList) xPixList = numpy.array(xPixList) yPixList = numpy.array(yPixList) xPupilList, yPupilList = \ pupilCoordsFromPixelCoords(xPixList, yPixList, nameList, camera=self.camera) testAnswer = gsdet.containsPupilCoordinates(xPupilList, yPupilList) for c, t in zip(correctAnswer, testAnswer): self.assertTrue(c is t)
def testContainsPupilCoordinates(self): """ Test whether or not the method containsRaDec correctly identifies RA and Dec that fall inside and outside the detector """ photParams = PhotometricParameters() gsdet = GalSimDetector(self.camera[0].getName(), GalSimCameraWrapper(self.camera), self.obs, self.epoch, photParams=photParams) xxList = [gsdet.xMinPix, gsdet.xMaxPix] yyList = [gsdet.yMinPix, gsdet.yMaxPix] dxList = [-1.0, 1.0] dyList = [-1.0, 1.0] xPixList = [] yPixList = [] correctAnswer = [] for xx, yy, dx, dy in zip(xxList, yyList, dxList, dyList): xPixList.append(xx) yPixList.append(yy) correctAnswer.append(True) xPixList.append(xx + dx) yPixList.append(yy) correctAnswer.append(False) xPixList.append(xx) yPixList.append(yy + dy) correctAnswer.append(False) nameList = [gsdet.name] * len(xPixList) xPixList = np.array(xPixList) yPixList = np.array(yPixList) xPupilList, yPupilList = \ pupilCoordsFromPixelCoords(xPixList, yPixList, nameList, camera=self.camera) testAnswer = gsdet.containsPupilCoordinates(xPupilList, yPupilList) for c, t in zip(correctAnswer, testAnswer): self.assertIs(c, t)
def pupilCoordsFromPixelCoords(self, xPix, yPix, chipName, obs_metadata, includeDistortion=True): """ Convert pixel coordinates into pupil coordinates Parameters ---------- xPix is the x pixel coordinate of the point. Can be either a float or a numpy array. yPix is the y pixel coordinate of the point. Can be either a float or a numpy array. chipName is the name of the chip(s) on which the pixel coordinates are defined. This can be a list (in which case there should be one chip name for each (xPix, yPix) coordinate pair), or a single value (in which case, all of the (xPix, yPix) points will be reckoned on that chip). obs_metadata is an ObservationMetaData characterizing the telescope pointing. includeDistortion is a boolean. If True (default), then this method will expect the true pixel coordinates with optical distortion included. If False, this method will expect TAN_PIXEL coordinates, which are the pixel coordinates with estimated optical distortion removed. See the documentation in afw.cameraGeom for more details. Returns ------- a 2-D numpy array in which the first row is the x pupil coordinate and the second row is the y pupil coordinate (both in radians) """ return coordUtils.pupilCoordsFromPixelCoords( xPix, yPix, chipName, camera=self._camera, includeDistortion=includeDistortion)
def pupilCoordsFromPixelCoordsLSST(xPix, yPix, chipName=None, band="r", includeDistortion=True): """ Convert pixel coordinates into radians on the pupil Parameters ---------- xPix -- the x pixel coordinate yPix -- the y pixel coordinate chipName -- the name(s) of the chips on which xPix, yPix are reckoned band -- the filter we are simulating (default=r) includeDistortion -- a boolean which turns on or off optical distortions (default=True) Returns ------- a 2-D numpy array in which the first row is the x pupil coordinate and the second row is the y pupil coordinate (both in radians) """ if not includeDistortion: return pupilCoordsFromPixelCoords(xPix, yPix, chipName=chipName, camera=lsst_camera(), includeDistortion=includeDistortion) are_arrays, \ chipNameList = _validate_inputs_and_chipname([xPix, yPix], ['xPix', 'yPix'], "pupilCoordsFromPixelCoords", chipName, chipname_can_be_none=False) pixel_to_focal_dict = {} camera = lsst_camera() name_to_int = {} name_to_int[None] = 0 name_to_int['None'] = 0 ii = 1 if are_arrays: chip_name_int = np.zeros(len(xPix), dtype=int) have_transform = set() for i_obj, name in enumerate(chipNameList): if name not in have_transform and name is not None and name != 'None': pixel_to_focal_dict[name] = camera[name].getTransform( PIXELS, FOCAL_PLANE) name_to_int[name] = ii have_transform.add(name) ii += 1 if are_arrays: chip_name_int[i_obj] = name_to_int[name] if are_arrays: x_f = np.zeros(len(xPix), dtype=float) y_f = np.zeros(len(yPix), dtype=float) for name in name_to_int: local_int = name_to_int[name] local_valid = np.where(chip_name_int == local_int) if len(local_valid[0]) == 0: continue if name is None or name == 'None': x_f[local_valid] = np.NaN y_f[local_valid] = np.NaN continue pixel_pt_arr = [ geom.Point2D(xPix[ii], yPix[ii]) for ii in local_valid[0] ] focal_pt_arr = pixel_to_focal_dict[name].applyForward(pixel_pt_arr) focal_coord_arr = np.array([[pt.getX(), pt.getY()] for pt in focal_pt_arr]).transpose() x_f[local_valid] = focal_coord_arr[0] y_f[local_valid] = focal_coord_arr[1] else: if chipNameList[0] is None or chipNameList[0] == 'None': x_f = np.NaN y_f = np.NaN else: pixel_pt = geom.Point2D(xPix, yPix) focal_pt = pixel_to_focal_dict[chipNameList[0]].applyForward( pixel_pt) x_f = focal_pt.getX() y_f = focal_pt.getY() return pupilCoordsFromFocalPlaneCoordsLSST(x_f, y_f, band=band)
def test_generic_camera_wrapper(self): """ Test that GalSimCameraWrapper wraps its methods as expected. This is mostly to catch changes in afw API. """ camera = camTestUtils.CameraWrapper().camera camera_wrapper = GalSimCameraWrapper(camera) obs_mjd = ObservationMetaData(mjd=60000.0) ra, dec = raDecFromAltAz(35.0, 112.0, obs_mjd) obs = ObservationMetaData(pointingRA=ra, pointingDec=dec, mjd=obs_mjd.mjd, rotSkyPos=22.4) rng = np.random.RandomState(8124) for detector in camera: name = detector.getName() bbox = camera[name].getBBox() bbox_wrapper = camera_wrapper.getBBox(name) self.assertEqual(bbox.getMinX(), bbox_wrapper.getMinX()) self.assertEqual(bbox.getMaxX(), bbox_wrapper.getMaxX()) self.assertEqual(bbox.getMinY(), bbox_wrapper.getMinY()) self.assertEqual(bbox.getMaxY(), bbox_wrapper.getMaxY()) center_point = camera[name].getCenter(FOCAL_PLANE) pixel_system = camera[name].makeCameraSys(PIXELS) center_pix = camera.transform(center_point, FOCAL_PLANE, pixel_system) center_pix_wrapper = camera_wrapper.getCenterPixel(name) self.assertEqual(center_pix.getX(), center_pix_wrapper.getX()) self.assertEqual(center_pix.getY(), center_pix_wrapper.getY()) pupil_system = camera[name].makeCameraSys(FIELD_ANGLE) center_pupil = camera.transform(center_point, FOCAL_PLANE, pupil_system) center_pupil_wrapper = camera_wrapper.getCenterPupil(name) self.assertEqual(center_pupil.getX(), center_pupil_wrapper.getX()) self.assertEqual(center_pupil.getY(), center_pupil_wrapper.getY()) corner_pupil_wrapper = camera_wrapper.getCornerPupilList(name) corner_point_list = camera[name].getCorners(FOCAL_PLANE) for point in corner_point_list: point_pupil = camera.transform(point, FOCAL_PLANE, pupil_system) dd_min = 1.0e10 for wrapper_point in corner_pupil_wrapper: dd = np.sqrt( (point_pupil.getX() - wrapper_point.getX())**2 + (point_pupil.getY() - wrapper_point.getY())**2) if dd < dd_min: dd_min = dd self.assertLess(dd_min, 1.0e-20) xpix_min = None xpix_max = None ypix_min = None ypix_max = None focal_to_tan_pix = camera[name].getTransform( FOCAL_PLANE, TAN_PIXELS) for point in corner_point_list: pixel_point = focal_to_tan_pix.applyForward(point) xx = pixel_point.getX() yy = pixel_point.getY() if xpix_min is None or xx < xpix_min: xpix_min = xx if ypix_min is None or yy < ypix_min: ypix_min = yy if xpix_max is None or xx > xpix_max: xpix_max = xx if ypix_max is None or yy > ypix_max: ypix_max = yy pix_bounds_wrapper = camera_wrapper.getTanPixelBounds(name) self.assertEqual(pix_bounds_wrapper[0], xpix_min) self.assertEqual(pix_bounds_wrapper[1], xpix_max) self.assertEqual(pix_bounds_wrapper[2], ypix_min) self.assertEqual(pix_bounds_wrapper[3], ypix_max) x_pup = rng.random_sample(10) * 0.005 - 0.01 y_pup = rng.random_sample(10) * 0.005 - 0.01 x_pix, y_pix = pixelCoordsFromPupilCoords(x_pup, y_pup, chipName=name, camera=camera) (x_pix_wrapper, y_pix_wrapper) = camera_wrapper.pixelCoordsFromPupilCoords( x_pup, y_pup, name, obs) nan_x = np.where(np.isnan(x_pix)) self.assertEqual(len(nan_x[0]), 0) np.testing.assert_array_equal(x_pix, x_pix_wrapper) np.testing.assert_array_equal(y_pix, y_pix_wrapper) x_pix = rng.random_sample(10) * 100.0 - 200.0 y_pix = rng.random_sample(10) * 100.0 - 200.0 x_pup, y_pup = pupilCoordsFromPixelCoords(x_pix, y_pix, chipName=name, camera=camera) (x_pup_wrapper, y_pup_wrapper) = camera_wrapper.pupilCoordsFromPixelCoords( x_pix, y_pix, name, obs) nan_x = np.where(np.isnan(x_pup)) self.assertEqual(len(nan_x[0]), 0) np.testing.assert_array_equal(x_pup, x_pup_wrapper) np.testing.assert_array_equal(y_pup, y_pup_wrapper) ra, dec = raDecFromPixelCoords(x_pix, y_pix, name, camera=camera, obs_metadata=obs) (ra_wrapper, dec_wrapper) = camera_wrapper.raDecFromPixelCoords( x_pix, y_pix, name, obs) nan_ra = np.where(np.isnan(ra)) self.assertEqual(len(nan_ra[0]), 0) np.testing.assert_array_equal(ra, ra_wrapper) np.testing.assert_array_equal(dec, dec_wrapper) ra, dec = _raDecFromPixelCoords(x_pix, y_pix, name, camera=camera, obs_metadata=obs) (ra_wrapper, dec_wrapper) = camera_wrapper._raDecFromPixelCoords( x_pix, y_pix, name, obs) nan_ra = np.where(np.isnan(ra)) self.assertEqual(len(nan_ra[0]), 0) np.testing.assert_array_equal(ra, ra_wrapper) np.testing.assert_array_equal(dec, dec_wrapper) ra = obs.pointingRA + (rng.random_sample(10) * 150.0 - 100.0) / 160.0 dec = obs.pointingDec + (rng.random_sample(10) * 150.0 - 100.0) / 160.0 x_pix, y_pix = pixelCoordsFromRaDec(ra, dec, chipName=name, camera=camera, obs_metadata=obs) (x_pix_wrapper, y_pix_wrapper) = camera_wrapper.pixelCoordsFromRaDec( ra, dec, chipName=name, obs_metadata=obs) nan_x = np.where(np.isnan(x_pix)) self.assertEqual(len(nan_x[0]), 0) np.testing.assert_array_equal(x_pix, x_pix_wrapper) np.testing.assert_array_equal(y_pix, y_pix_wrapper) ra = np.radians(ra) dec = np.radians(dec) x_pix, y_pix = _pixelCoordsFromRaDec(ra, dec, chipName=name, camera=camera, obs_metadata=obs) (x_pix_wrapper, y_pix_wrapper) = camera_wrapper._pixelCoordsFromRaDec( ra, dec, chipName=name, obs_metadata=obs) nan_x = np.where(np.isnan(x_pix)) self.assertEqual(len(nan_x[0]), 0) np.testing.assert_array_equal(x_pix, x_pix_wrapper) np.testing.assert_array_equal(y_pix, y_pix_wrapper) del camera
def _build_lsst_pupil_coord_map(): """ This method populates the global variable _lsst_pupil_coord_map _lsst_pupil_coord_map['name'] contains a list of the names of each chip in the lsst camera _lsst_pupil_coord_map['xx'] contains the x pupil coordinate of the center of each chip _lsst_pupil_coord_map['yy'] contains the y pupil coordinate of the center of each chip _lsst_pupil_coord_map['dp'] contains the radius (in pupil coordinates) of the circle containing each chip """ global _lsst_pupil_coord_map if _lsst_pupil_coord_map is not None: raise RuntimeError("Calling _build_pupil_coord_map(), " "but it is already built.") name_list = [] x_pix_list = [] y_pix_list = [] n_chips = 0 for chip in lsst_camera(): chip_name = chip.getName() n_chips += 1 corner_list = getCornerPixels(chip_name, lsst_camera()) for corner in corner_list: x_pix_list.append(corner[0]) y_pix_list.append(corner[1]) name_list.append(chip_name) x_pix_list = np.array(x_pix_list) y_pix_list = np.array(y_pix_list) x_pup_list, y_pup_list = pupilCoordsFromPixelCoords(x_pix_list, y_pix_list, name_list, camera=lsst_camera()) center_x = np.zeros(n_chips, dtype=float) center_y = np.zeros(n_chips, dtype=float) extent = np.zeros(n_chips, dtype=float) final_name = [] for ix_ct in range(n_chips): ix = ix_ct*4 chip_name = name_list[ix] xx = 0.25*(x_pup_list[ix] + x_pup_list[ix+1] + x_pup_list[ix+2] + x_pup_list[ix+3]) yy = 0.25*(y_pup_list[ix] + y_pup_list[ix+1] + y_pup_list[ix+2] + y_pup_list[ix+3]) dx = 0.25*np.array([np.sqrt(np.power(xx-x_pup_list[ix+ii], 2) + np.power(yy-y_pup_list[ix+ii], 2)) for ii in range(4)]).sum() center_x[ix_ct] = xx center_y[ix_ct] = yy extent[ix_ct] = dx final_name.append(chip_name) final_name = np.array(final_name) _lsst_pupil_coord_map = {} _lsst_pupil_coord_map['name'] = final_name _lsst_pupil_coord_map['xx'] = center_x _lsst_pupil_coord_map['yy'] = center_y _lsst_pupil_coord_map['dp'] = extent