def create_sample_image(psi='-30d'): seed(10) # set up the sample image using a HESS camera geometry (since it's easy # to load) geom = CameraGeometry.from_name("HESS", 1) # make a toymodel shower model model = toymodel.generate_2d_shower_model(centroid=(0.2, 0.3), width=0.001, length=0.01, psi=psi) # generate toymodel image in camera for this shower model. image, signal, noise = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=50, nsb_level_pe=100) # denoise the image, so we can calculate hillas params clean_mask = tailcuts_clean(geom, image, 1, 10, 5) # pedvars = 1 and core and boundary # threshold in pe image[~clean_mask] = 0 # Pixel values in the camera pix_x = geom.pix_x.value pix_y = geom.pix_y.value return pix_x, pix_y, image
def create_sample_image(): # set up the sample image using a HESS camera geometry (since it's easy # to load) geom = CameraGeometry.from_name("HESS", 1) # make a toymodel shower model model = toymodel.generate_2d_shower_model(centroid=(0.2, 0.3), width=0.001, length=0.01, psi='30d') # generate toymodel image in camera for this shower model. image, signal, noise = toymodel.make_toymodel_shower_image(geom, model.pdf, intensity=50, nsb_level_pe=100) # denoise the image, so we can calculate hillas params clean_mask = tailcuts_clean(geom, image, 1, 10, 5) # pedvars = 1 and core and boundary # threshold in pe image[~clean_mask] = 0 # Pixel values in the camera pix_x = geom.pix_x.value pix_y = geom.pix_y.value return pix_x, pix_y, image
def update(frame): centroid = np.random.uniform(-0.5, 0.5, size=2) width = np.random.uniform(0, 0.01) length = np.random.uniform(0, 0.03) + width angle = np.random.uniform(0, 360) intens = np.random.exponential(2) * 50 model = toymodel.generate_2d_shower_model(centroid=centroid, width=width, length=length, psi=angle * u.deg) image, sig, bg = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=intens, nsb_level_pe=5000) # alternate between cleaned and raw images if self._counter > 20: plt.suptitle("Image Cleaning ON") cleanmask = cleaning.tailcuts_clean(geom, image, pedvars=80) for ii in range(3): cleaning.dilate(geom, cleanmask) image[cleanmask == 0] = 0 # zero noise pixels if self._counter >= 40: plt.suptitle("Image Cleaning OFF") self._counter = 0 disp.image = image disp.set_limits_percent(100) self._counter += 1
def update(frame): centroid = np.random.uniform(-0.5, 0.5, size=2) width = np.random.uniform(0, 0.01) length = np.random.uniform(0, 0.03) + width angle = np.random.uniform(0, 360) intens = np.random.exponential(2) * 50 model = toymodel.generate_2d_shower_model(centroid=centroid, width=width, length=length, psi=angle * u.deg) image, sig, bg = toymodel.make_toymodel_shower_image(geom, model.pdf, intensity=intens, nsb_level_pe=5000) # alternate between cleaned and raw images if self._counter > 20: plt.suptitle("Image Cleaning ON") cleanmask = cleaning.tailcuts_clean(geom, image, pedvars=80) for ii in range(3): cleaning.dilate(geom, cleanmask) image[cleanmask == 0] = 0 # zero noise pixels if self._counter >= 40: plt.suptitle("Image Cleaning OFF") self._counter = 0 disp.image = image disp.set_limits_percent(100) self._counter += 1
def test_convert_geometry(cam_id, rot): geom = CameraGeometry.from_name(cam_id) if geom.pix_type == 'rectangular': return # skip non-hexagonal cameras, since they don't need conversion model = generate_2d_shower_model(centroid=(0.4, 0), width=0.01, length=0.03, psi="25d") _, image, _ = make_toymodel_shower_image(geom, model.pdf, intensity=50, nsb_level_pe=100) hillas_0 = hillas_parameters(geom.pix_x, geom.pix_y, image) geom2d, image2d = convert_geometry_1d_to_2d(geom, image, geom.cam_id + str(rot), add_rot=rot) geom1d, image1d = convert_geometry_back(geom2d, image2d, geom.cam_id + str(rot), add_rot=rot) hillas_1 = hillas_parameters(geom1d.pix_x, geom1d.pix_y, image1d) if __name__ == "__main__": plot_cam(geom, geom2d, geom1d, image, image2d, image1d) plt.tight_layout() plt.pause(.1) assert np.abs(hillas_1.phi - hillas_0.phi).deg < 1.0
def create_sample_image(psi='-30d'): seed(10) # set up the sample image using a HESS camera geometry (since it's easy # to load) geom = CameraGeometry.from_name("LSTCam") # make a toymodel shower model model = toymodel.generate_2d_shower_model( centroid=(0.2, 0.3), width=0.05, length=0.15, psi=psi, ) # generate toymodel image in camera for this shower model. image, signal, noise = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=1500, nsb_level_pe=3, ) # denoise the image, so we can calculate hillas params clean_mask = tailcuts_clean(geom, image, 10, 5) return geom, image, clean_mask
def test_convert_geometry(cam_id, rot): geom = CameraGeometry.from_name(cam_id) if geom.pix_type=='rectangular': return # skip non-hexagonal cameras, since they don't need conversion model = generate_2d_shower_model(centroid=(0.4, 0), width=0.01, length=0.03, psi="25d") _,image,_ = make_toymodel_shower_image(geom, model.pdf, intensity=50, nsb_level_pe=100) hillas_0 = hillas_parameters(geom.pix_x, geom.pix_y, image) geom2d, image2d = convert_geometry_1d_to_2d(geom, image, geom.cam_id+str(rot), add_rot=-2) geom1d, image1d = convert_geometry_back(geom2d, image2d, geom.cam_id+str(rot), add_rot=rot) hillas_1 = hillas_parameters(geom1d.pix_x, geom1d.pix_y, image1d) if __name__ == "__main__": plot_cam(geom, geom2d, geom1d, image, image2d, image1d) assert np.abs(hillas_1.phi - hillas_0.phi).deg < 1.0
def draw_several_cams(geom, ncams=4): cmaps = ['jet', 'afmhot', 'terrain', 'autumn'] fig, axs = plt.subplots(1, ncams, figsize=(15, 4), sharey=True, sharex=True) for ii in range(ncams): disp = visualization.CameraDisplay( geom, ax=axs[ii], title="CT{}".format(ii + 1), ) disp.cmap = cmaps[ii] model = toymodel.generate_2d_shower_model( centroid=(0.2 - ii * 0.1, -ii * 0.05), width=0.005 + 0.001 * ii, length=0.1 + 0.05 * ii, psi=ii * 20 * u.deg, ) image, sig, bg = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=50, nsb_level_pe=1000, ) clean = image.copy() clean[image <= 3.0 * image.mean()] = 0.0 hillas = hillas_parameters(geom.pix_x, geom.pix_y, clean) disp.image = image disp.add_colorbar(ax=axs[ii]) disp.set_limits_percent(95) disp.overlay_moments(hillas, linewidth=3, color='blue')
def test_convert_geometry(cam_id, rot): geom = CameraGeometry.from_name(cam_id) model = generate_2d_shower_model(centroid=(0.4, 0), width=0.01, length=0.03, psi="25d") _, image, _ = make_toymodel_shower_image(geom, model.pdf, intensity=50, nsb_level_pe=100) hillas_0 = hillas_parameters(geom, image) if geom.pix_type == 'hexagonal': convert_geometry_1d_to_2d = convert_geometry_hex1d_to_rect2d convert_geometry_back = convert_geometry_rect2d_back_to_hexe1d geom2d, image2d = convert_geometry_1d_to_2d(geom, image, geom.cam_id + str(rot), add_rot=rot) geom1d, image1d = convert_geometry_back(geom2d, image2d, geom.cam_id + str(rot), add_rot=rot) else: if geom.cam_id == "ASTRICam": convert_geometry_1d_to_2d = astri_to_2d_array convert_geometry_back = array_2d_to_astri elif geom.cam_id == "CHEC": convert_geometry_1d_to_2d = chec_to_2d_array convert_geometry_back = array_2d_to_chec else: print("camera {geom.cam_id} not implemented") return image2d = convert_geometry_1d_to_2d(image) image1d = convert_geometry_back(image2d) hillas_1 = hillas_parameters(geom, image1d) # if __name__ == "__main__": # plot_cam(geom, geom2d, geom1d, image, image2d, image1d) # plt.tight_layout() # plt.pause(.1) assert np.abs(hillas_1.phi - hillas_0.phi).deg < 1.0
def draw_several_cams(geom, ncams=4): cmaps = ['jet', 'afmhot', 'terrain', 'autumn'] fig, axs = plt.subplots( 1, ncams, figsize=(15, 4), ) for ii in range(ncams): disp = CameraDisplay( geom, ax=axs[ii], title="CT{}".format(ii + 1), ) disp.cmap = cmaps[ii] model = toymodel.generate_2d_shower_model( centroid=(0.2 - ii * 0.1, -ii * 0.05), width=0.05 + 0.001 * ii, length=0.15 + 0.05 * ii, psi=ii * 20 * u.deg, ) image, sig, bg = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=1500, nsb_level_pe=5, ) mask = tailcuts_clean( geom, image, picture_thresh=6 * image.mean(), boundary_thresh=4 * image.mean() ) cleaned = image.copy() cleaned[~mask] = 0 hillas = hillas_parameters(geom, cleaned) disp.image = image disp.add_colorbar(ax=axs[ii]) disp.set_limits_percent(95) disp.overlay_moments(hillas, linewidth=3, color='blue')
def draw_several_cams(geom, ncams=4): cmaps = ['jet', 'afmhot', 'terrain', 'autumn'] fig, axs = plt.subplots( 1, ncams, figsize=(15, 4), ) for ii in range(ncams): disp = CameraDisplay( geom, ax=axs[ii], title="CT{}".format(ii + 1), ) disp.cmap = cmaps[ii] model = toymodel.generate_2d_shower_model( centroid=(0.2 - ii * 0.1, -ii * 0.05), width=0.05 + 0.001 * ii, length=0.15 + 0.05 * ii, psi=ii * 20 * u.deg, ) image, sig, bg = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=1500, nsb_level_pe=5, ) mask = tailcuts_clean(geom, image, picture_thresh=6 * image.mean(), boundary_thresh=4 * image.mean()) cleaned = image.copy() cleaned[~mask] = 0 hillas = hillas_parameters(geom, cleaned) disp.image = image disp.add_colorbar(ax=axs[ii]) disp.set_limits_percent(95) disp.overlay_moments(hillas, linewidth=3, color='blue')
def create_mock_image(geom): ''' creates a mock image, which parameters are adapted to the camera size ''' camera_r = np.max(np.sqrt(geom.pix_x**2 + geom.pix_y**2)) model = generate_2d_shower_model(centroid=(0.3 * camera_r.value, 0), width=0.03 * camera_r.value, length=0.10 * camera_r.value, psi="25d") _, image, _ = make_toymodel_shower_image( geom, model.pdf, intensity=0.5 * geom.n_pixels, nsb_level_pe=3, ) return image
def update(frame): self.log.debug("Frame=", frame) centroid = np.random.uniform(-fov, fov, size=2) * scale width = np.random.uniform(0, maxwid) * scale length = np.random.uniform(0, maxlen) * scale + width angle = np.random.uniform(0, 360) intens = np.random.exponential(2) * 50 model = toymodel.generate_2d_shower_model(centroid=centroid, width=width, length=length, psi=angle * u.deg) image, sig, bg = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=intens, nsb_level_pe=5000) # alternate between cleaned and raw images if self._counter == self.cleanframes: plt.suptitle("Image Cleaning ON") self.imclean = True if self._counter == self.cleanframes * 2: plt.suptitle("Image Cleaning OFF") self.imclean = False self._counter = 0 if self.imclean: cleanmask = tailcuts_clean(geom, image / 80.0) for ii in range(3): dilate(geom, cleanmask) image[cleanmask == 0] = 0 # zero noise pixels self.log.debug("count = {}, image sum={} max={}".format( self._counter, image.sum(), image.max())) disp.image = image if self.autoscale: disp.set_limits_percent(95) else: disp.set_limits_minmax(-100, 4000) disp.axes.figure.canvas.draw() self._counter += 1 return [ ax, ]
def create_mock_image(geom): ''' creates a mock image, which parameters are adapted to the camera size ''' camera_r = np.max(np.sqrt(geom.pix_x**2 + geom.pix_y**2)) model = generate_2d_shower_model( centroid=(0.3 * camera_r.value, 0), width=0.03 * camera_r.value, length=0.10 * camera_r.value, psi="25d" ) _, image, _ = make_toymodel_shower_image( geom, model.pdf, intensity=0.5 * geom.n_pixels, nsb_level_pe=3, ) return image
def test_with_toy(): np.random.seed(42) geom = CameraGeometry.from_name('LSTCam') width = 0.03 length = 0.15 intensity = 500 xs = (0.5, 0.5, -0.5, -0.5) ys = (0.5, -0.5, 0.5, -0.5) psis = Angle([-90, -45, 0, 45, 90], unit='deg') for x, y in zip(xs, ys): for psi in psis: # make a toymodel shower model model = toymodel.generate_2d_shower_model( centroid=(x, y), width=width, length=length, psi=psi, ) image, signal, noise = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=intensity, nsb_level_pe=5, ) result = hillas_parameters(geom, signal) assert result.x.to_value(u.m) == approx(x, rel=0.1) assert result.y.to_value(u.m) == approx(y, rel=0.1) assert result.width.to_value(u.m) == approx(width, rel=0.1) assert result.length.to_value(u.m) == approx(length, rel=0.1) assert ((result.psi.to_value(u.deg) == approx(psi.deg, abs=2)) or abs(result.psi.to_value(u.deg) - psi.deg) == approx( 180.0, abs=2)) assert signal.sum() == result.intensity
def update(frame): centroid = np.random.uniform(-fov, fov, size=2) * scale width = np.random.uniform(0, maxwid) * scale length = np.random.uniform(0, maxlen) * scale + width angle = np.random.uniform(0, 360) intens = np.random.exponential(2) * 50 model = toymodel.generate_2d_shower_model( centroid=centroid, width=width, length=length, psi=angle * u.deg, ) image, sig, bg = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=intens, nsb_level_pe=5000, ) image /= image.max() disp.image = image
def update(frame): centroid = np.random.uniform(-0.5, 0.5, size=2) width = np.random.uniform(0, 0.01) length = np.random.uniform(0, 0.03) + width angle = np.random.uniform(0, 360) intens = np.random.exponential(2) * 50 model = toymodel.generate_2d_shower_model(centroid=centroid, width=width, length=length, psi=angle * u.deg) image, sig, bg = toymodel.make_toymodel_shower_image(geom, model.pdf, intensity=intens, nsb_level_pe=5000) # alternate between cleaned and raw images if self._counter == self.cleanframes: plt.suptitle("Image Cleaning ON") self.imclean = True if self._counter == self.cleanframes*2: plt.suptitle("Image Cleaning OFF") self.imclean = False self._counter = 0 if self.imclean: cleanmask = tailcuts_clean(geom, image/80.0) for ii in range(3): dilate(geom, cleanmask) image[cleanmask == 0] = 0 # zero noise pixels self.log.debug("count = {}, image sum={} max={}" .format(self._counter, image.sum(), image.max())) disp.image = image if self.autoscale: disp.set_limits_percent(95) else: disp.set_limits_minmax(-100, 4000) disp.axes.figure.canvas.draw() self._counter += 1 return [ax,]
def update(frame): centroid = np.random.uniform(-fov, fov, size=2) width = np.random.uniform(0.01, maxwid) length = np.random.uniform(width, maxlen) angle = np.random.uniform(0, 180) intens = width * length * (5e4 + 1e5 * np.random.exponential(2)) model = toymodel.generate_2d_shower_model( centroid=centroid, width=width, length=length, psi=angle * u.deg, ) image, sig, bg = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=intens, nsb_level_pe=5, ) disp.image = image
def test_convert_geometry_mock(cam_id, rot): """here we use a different key for the back conversion to trigger the mock conversion """ geom = CameraGeometry.from_name(cam_id) model = generate_2d_shower_model(centroid=(0.4, 0), width=0.01, length=0.03, psi="25d") _, image, _ = make_toymodel_shower_image(geom, model.pdf, intensity=50, nsb_level_pe=100) hillas_0 = hillas_parameters(geom, image) if geom.pix_type == 'hexagonal': convert_geometry_1d_to_2d = convert_geometry_hex1d_to_rect2d convert_geometry_back = convert_geometry_rect2d_back_to_hexe1d geom2d, image2d = convert_geometry_1d_to_2d(geom, image, key=None, add_rot=rot) geom1d, image1d = convert_geometry_back( geom2d, image2d, "_".join([geom.cam_id, str(rot), "mock"]), add_rot=rot) else: # originally rectangular geometries don't need a buffer and therefore no mock # conversion return hillas_1 = hillas_parameters(geom, image1d) assert np.abs(hillas_1.phi - hillas_0.phi).deg < 1.0
"""Example how to make a toymodel shower image and plot it. """ import matplotlib.pyplot as plt from ctapipe.io.camera import make_rectangular_camera_geometry from ctapipe.image.toymodel import generate_2d_shower_model, make_toymodel_shower_image NX = 40 NY = 40 geom = make_rectangular_camera_geometry(NX, NY) showermodel = generate_2d_shower_model(centroid=[0.25, 0.0], length=0.1, width=0.02, psi='40d') image, signal, noise = make_toymodel_shower_image(geom, showermodel.pdf, intensity=20, nsb_level_pe=30) # make them into 2D arrays so we can plot them with imshow image.shape = (NX, NY) signal.shape = (NX, NY) noise.shape = (NX, NY) # here we just plot the images using imshow(). For a more general # case, one should use a ctapipe.visualization.CameraDisplay plt.figure(figsize=(10, 3)) plt.subplot(1, 3, 1) plt.imshow(signal, interpolation='nearest', origin='lower') plt.title("Signal") plt.colorbar() plt.subplot(1, 3, 2) plt.imshow(noise, interpolation='nearest', origin='lower')
for nn in neigh: nx, ny = geom.pix_x[nn].value, geom.pix_y[nn].value plt.plot([x, nx], [y, ny], color=color, **kwargs) if __name__ == '__main__': # Load the camera geom = CameraGeometry.from_name("LSTCam") disp = CameraDisplay(geom) disp.set_limits_minmax(0, 300) disp.add_colorbar() # Create a fake camera image to display: model = toymodel.generate_2d_shower_model(centroid=(0.2, 0.0), width=0.01, length=0.1, psi='35d') image, sig, bg = toymodel.make_toymodel_shower_image(geom, model.pdf, intensity=50, nsb_level_pe=1000) # Apply image cleaning cleanmask = tailcuts_clean(geom, image, picture_thresh=200, boundary_thresh=100) clean = image.copy() clean[~cleanmask] = 0.0 # Calculate image parameters hillas = hillas_parameters(geom.pix_x, geom.pix_y, clean) print(hillas)
def toymodel_event_source(geoms, max_events=100, single_tel=False, n_channels=1, n_samples=25, p_trigger=0.3): """ An event source that produces array Parameters ---------- geoms : list of CameraGeometry instances Geometries for the telescopes to simulate max_events : int, default: 100 maximum number of events to create n_channels : int how many channels per telescope n_samples : int how many adc samples per pixel p_trigger : float mean trigger probability for the telescopes """ n_telescopes = len(geoms) container = DataContainer() container.meta['toymodel__max_events'] = max_events container.meta['source'] = "toymodel" tel_ids = np.arange(n_telescopes) for event_id in range(max_events): n_triggered = np.random.poisson(n_telescopes * 0.3) if n_triggered > n_telescopes: n_triggered = n_telescopes triggered_tels = np.random.choice(tel_ids, n_triggered, replace=False) container.r0.event_id = event_id container.r0.tels_with_data = triggered_tels container.count = event_id # handle single-telescope case (ignore others: if single_tel: if single_tel not in container.r0.tels_with_data: continue container.r0.tels_with_data = [single_tel, ] container.r0.tel.reset() # clear the previous telescopes t = np.arange(n_samples) for tel_id in container.r0.tels_with_data: geom = geoms[tel_id] # fill pixel position dictionary, if not already done: if tel_id not in container.inst.pixel_pos: container.inst.pixel_pos[tel_id] = ( geom.pix_x.value, geom.pix_y.value, ) centroid = np.random.uniform(geom.pix_x.min(), geom.pix_y.max(), 2) length = np.random.uniform(0.02, 0.2) width = np.random.uniform(0.01, length) psi = np.random.randint(0, 360) intensity = np.random.poisson(int(10000 * width * length)) model = toymodel.generate_2d_shower_model( centroid, width, length, '{}d'.format(psi) ) image, _, _ = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity, ) # container.r0.tel[tel_id] = R0CameraContainer() container.inst.num_channels[tel_id] = n_channels n_pix = len(geom.pix_id) samples = np.empty((n_pix, n_samples)) means = np.random.normal(15, 1, (n_pix, 1)) stds = np.random.uniform(3, 6, (n_pix, 1)) samples = image[:, np.newaxis] * norm.pdf(t, means, stds) for chan in range(n_channels): container.r0.tel[tel_id].adc_samples[chan] = samples container.r0.tel[tel_id].adc_sums[chan] = image yield container
from ctapipe.image import toymodel from ctapipe.io import CameraGeometry from ctapipe.visualization import CameraDisplay from matplotlib import pyplot as plt if __name__ == '__main__': plt.style.use('ggplot') fig = plt.figure(figsize=(12, 8)) ax = fig.add_subplot(1, 1, 1) geom = CameraGeometry.from_name('hess', 1) disp = CameraDisplay(geom, ax=ax) disp.add_colorbar() model = toymodel.generate_2d_shower_model( centroid=(0.05, 0.0), width=0.005, length=0.025, psi='35d' ) image, sig, bg = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=50, nsb_level_pe=20 ) disp.image = image mask = disp.image > 15 disp.highlight_pixels(mask, linewidth=3) plt.show()
def toymodel_event_source(geoms, max_events=100, single_tel=False, n_channels=1, n_samples=25, p_trigger=0.3): """ An event source that produces array Parameters ---------- geoms : list of CameraGeometry instances Geometries for the telescopes to simulate max_events : int, default: 100 maximum number of events to create n_channels : int how many channels per telescope n_samples : int how many adc samples per pixel p_trigger : float mean trigger probability for the telescopes """ n_telescopes = len(geoms) container = DataContainer() container.meta['toymodel__max_events'] = max_events container.meta['source'] = "toymodel" tel_ids = np.arange(n_telescopes) for event_id in range(max_events): n_triggered = np.random.poisson(n_telescopes * 0.3) if n_triggered > n_telescopes: n_triggered = n_telescopes triggered_tels = np.random.choice(tel_ids, n_triggered, replace=False) container.r0.event_id = event_id container.r0.tels_with_data = triggered_tels container.count = event_id # handle single-telescope case (ignore others: if single_tel: if single_tel not in container.r0.tels_with_data: continue container.r0.tels_with_data = [ single_tel, ] container.r0.tel.reset() # clear the previous telescopes t = np.arange(n_samples) for tel_id in container.r0.tels_with_data: geom = geoms[tel_id] # fill pixel position dictionary, if not already done: if tel_id not in container.inst.pixel_pos: container.inst.pixel_pos[tel_id] = ( geom.pix_x.value, geom.pix_y.value, ) centroid = np.random.uniform(geom.pix_x.min(), geom.pix_y.max(), 2) length = np.random.uniform(0.02, 0.2) width = np.random.uniform(0.01, length) psi = np.random.randint(0, 360) intensity = np.random.poisson(int(10000 * width * length)) model = toymodel.generate_2d_shower_model(centroid, width, length, '{}d'.format(psi)) image, _, _ = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity, ) # container.r0.tel[tel_id] = R0CameraContainer() container.inst.num_channels[tel_id] = n_channels n_pix = len(geom.pix_id) means = np.random.normal(15, 1, (n_pix, 1)) stds = np.random.uniform(3, 6, (n_pix, 1)) samples = image[:, np.newaxis] * norm.pdf(t, means, stds) for chan in range(n_channels): container.r0.tel[tel_id].waveform[chan] = samples container.r0.tel[tel_id].image[chan] = image yield container
def update(frame): centroid = np.random.uniform(-fov, fov, size=2) * scale width = np.random.uniform(0, maxwid-minwid) * scale + minwid length = np.random.uniform(0, maxlen) * scale + width angle = np.random.uniform(0, 360) intens = np.random.exponential(2) * 500 model = toymodel.generate_2d_shower_model(centroid=centroid, width=width, length=length, psi=angle * u.deg) self.log.debug( "Frame=%d width=%03f length=%03f intens=%03d", frame, width, length, intens ) image, sig, bg = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=intens, nsb_level_pe=3, ) # alternate between cleaned and raw images if self._counter == self.cleanframes: plt.suptitle("Image Cleaning ON") self.imclean = True if self._counter == self.cleanframes * 2: plt.suptitle("Image Cleaning OFF") self.imclean = False self._counter = 0 disp.clear_overlays() if self.imclean: cleanmask = tailcuts_clean(geom, image, picture_thresh=10.0, boundary_thresh=5.0) for ii in range(2): dilate(geom, cleanmask) image[cleanmask == 0] = 0 # zero noise pixels try: hillas = hillas_parameters(geom, image) disp.overlay_moments(hillas, with_label=False, color='red', alpha=0.7, linewidth=2, linestyle='dashed') except HillasParameterizationError: disp.clear_overlays() pass self.log.debug("Frame=%d image_sum=%.3f max=%.3f", self._counter, image.sum(), image.max()) disp.image = image if self.autoscale: disp.set_limits_percent(95) else: disp.set_limits_minmax(-5, 200) disp.axes.figure.canvas.draw() self._counter += 1 return [ax, ]
"""Example how to make a toymodel shower image and plot it. """ import matplotlib.pyplot as plt from ctapipe.io.camera import make_rectangular_camera_geometry from ctapipe.image.toymodel import generate_2d_shower_model, make_toymodel_shower_image NX = 40 NY = 40 geom = make_rectangular_camera_geometry(NX, NY) showermodel = generate_2d_shower_model(centroid=[0.25, 0.0], length=0.1, width=0.02, psi='40d') image, signal, noise = make_toymodel_shower_image(geom, showermodel.pdf, intensity=20, nsb_level_pe=30) # make them into 2D arrays so we can plot them with imshow image.shape = (NX, NY) signal.shape = (NX, NY) noise.shape = (NX, NY) # here we just plot the images using imshow(). For a more general # case, one should use a ctapipe.visualization.CameraDisplay plt.figure(figsize=(10, 3)) plt.subplot(1, 3, 1) plt.imshow(signal, interpolation='nearest', origin='lower')
from ctapipe.instrument import CameraGeometry from ctapipe.visualization import CameraDisplay if __name__ == '__main__': plt.style.use('ggplot') fig = plt.figure(figsize=(12, 8)) ax = fig.add_subplot(1, 1, 1) geom = CameraGeometry.from_name('NectarCam') disp = CameraDisplay(geom, ax=ax) disp.add_colorbar() model = toymodel.generate_2d_shower_model(centroid=(0.05, 0.0), width=0.005, length=0.025, psi='35d') image, sig, bg = toymodel.make_toymodel_shower_image(geom, model.pdf, intensity=50, nsb_level_pe=20) disp.image = image mask = disp.image > 15 disp.highlight_pixels(mask, linewidth=3) plt.show()
def update(frame): centroid = np.random.uniform(-fov, fov, size=2) * scale width = np.random.uniform(0, maxwid - minwid) * scale + minwid length = np.random.uniform(0, maxlen) * scale + width angle = np.random.uniform(0, 360) intens = np.random.exponential(2) * 500 model = toymodel.generate_2d_shower_model(centroid=centroid, width=width, length=length, psi=angle * u.deg) self.log.debug("Frame=%d width=%03f length=%03f intens=%03d", frame, width, length, intens) image, sig, bg = toymodel.make_toymodel_shower_image( geom, model.pdf, intensity=intens, nsb_level_pe=3, ) # alternate between cleaned and raw images if self._counter == self.cleanframes: plt.suptitle("Image Cleaning ON") self.imclean = True if self._counter == self.cleanframes * 2: plt.suptitle("Image Cleaning OFF") self.imclean = False self._counter = 0 disp.clear_overlays() if self.imclean: cleanmask = tailcuts_clean(geom, image, picture_thresh=10.0, boundary_thresh=5.0) for ii in range(2): dilate(geom, cleanmask) image[cleanmask == 0] = 0 # zero noise pixels try: hillas = hillas_parameters(geom, image) disp.overlay_moments(hillas, with_label=False, color='red', alpha=0.7, linewidth=2, linestyle='dashed') except HillasParameterizationError: disp.clear_overlays() pass self.log.debug("Frame=%d image_sum=%.3f max=%.3f", self._counter, image.sum(), image.max()) disp.image = image if self.autoscale: disp.set_limits_percent(95) else: disp.set_limits_minmax(-5, 200) disp.axes.figure.canvas.draw() self._counter += 1 return [ ax, ]