def test_undense_point_source(session, angular_distribution, wavelengths): source = sources.PointSource( (0.0, 0.0), 0.0, angular_distribution, wavelengths, dense=False ) result = session.run(source.rays) assert source.rays.dtype == tf.float64 assert result.shape[1] == 5 assert result.shape[0] == wavelengths.shape[0]
def test_simple_params_constant( session, center, central_angle, sample_angular_distribution, sample_wavelengths ): source = sources.PointSource( center, central_angle, sample_angular_distribution, sample_wavelengths, dense=True, ) result = session.run(source.rays) assert source.rays.dtype == tf.float64 assert result.shape == (25, 5)
def test_simple_params_feed( session, center, central_angle, sample_angular_distribution, sample_wavelengths ): source = sources.PointSource( feed_center, feed_central_angle, sample_angular_distribution, sample_wavelengths, dense=True, ) result = session.run( source.rays, feed_dict={feed_center: center, feed_central_angle: central_angle} ) assert source.rays.dtype == tf.float64 assert result.shape == (25, 5)
import tfrt.distributions as dist import tfrt.drawing as drawing import tfrt.sources as sources import tfrt.boundaries as boundaries import tfrt.engine as engine PI = tf.constant(pi, dtype=tf.float64) # Set up the source angular_size = PI / 8 print(f"Angular Size: {np.degrees(angular_size)}") #sphere = dist.StaticUniformSphere(angular_size, 100000) #sphere = dist.RandomUniformSphere(angular_size, 100000) #sphere = dist.StaticLambertianSphere(angular_size, 100000) sphere = dist.RandomLambertianSphere(angular_size, 100000) source = sources.PointSource(3, (0, 0, 0), (1, 0, 0), sphere, [drawing.YELLOW]) source.frozen = True print(f"Minimum phi generated: {np.degrees(tf.reduce_min(sphere.ranks[:,0]))}") print(f"Maximum phi generated: {np.degrees(tf.reduce_max(sphere.ranks[:,0]))}") # Set up the target angular_step_size = 5 plane_mesh = pv.Plane((1, 0, 0), (1, 0, 0), i_size=.1, j_size=.1).triangulate() target = boundaries.ManualTriangleBoundary(mesh=plane_mesh) # set up the system system = engine.OpticalSystem3D() system.sources = [source] system.targets = [target] eng = engine.OpticalEngine(3, [], optical_system=system)
import tensorflow as tf import numpy as np import tfrt.sources as sources import tfrt.distributions as distributions import tfrt.drawing as drawing PI = sources.PI source = sources.PrecompiledSource(2, do_downsample=False) angles = distributions.RandomUniformAngularDistribution(-PI / 4, PI / 4, 5) sampling_source = sources.PointSource(2, (0, 0), 0, angles, [drawing.YELLOW]) samples = [sampling_source.snapshot() for i in range(5)] source.from_samples(samples) for field, item in source.items(): print(f"{field}: {item}")
from tfrt.spectrumRGB import rgb angular_size = itertools.cycle( np.array([PI / 2, PI / 3, PI / 4, PI / 8, PI / 12, PI / 48], dtype=np.float64)) sample_count = itertools.cycle([5, 9, 25]) center = itertools.cycle([(0, 0), (3, 0), (0, 3)]) central_angle = itertools.cycle([0, PI / 4, PI / 2, PI, -PI / 2]) # build the source rays start_angle = next(angular_size) angles = distributions.StaticUniformAngularDistribution( -start_angle, start_angle, next(sample_count)) source = sources.PointSource(2, next(center), next(central_angle), angles, [drawing.YELLOW], dense=True) fig, ax = plt.subplots(1, 1, figsize=(8, 6)) ax.set_aspect("equal") ax.set_xbound(-4, 4) ax.set_ybound(-4, 4) drawer = drawing.RayDrawer2D(ax) drawing.disable_figure_key_commands() def redraw(): source.update() drawer.rays = source drawer.draw()
import tfrt.sources as sources import tfrt.distributions as distributions import tfrt.drawing as drawing import tfrt.boundaries as boundaries import tfrt.engine as engine import tfrt.operation as operation import tfrt.materials as materials PI = tf.constant(pi, dtype=tf.float64) # build the source rays #base_points = distributions.StaticUniformSquare(1, 5) angles = distributions.StaticUniformSphere(PI / 8.0, 25) source = sources.PointSource(3, (-1, 0, 0), (1, 0, 0), angles, drawing.RAINBOW_6, dense=True) source.frozen = True # build the boundary surface1 = boundaries.ManualTriangleBoundary( file_name="./stl/short_pyramid.stl", material_dict={ "mat_in": 1, "mat_out": 0 }) surface2 = boundaries.ManualTriangleBoundary(mesh=pv.Sphere(radius=.5, center=(1, 0, 0)), material_dict={ "mat_in": 1, "mat_out": 0
drawer.draw() drawing.redraw_current_figure() if __name__ == "__main__": drawing.disable_figure_key_commands() # set up the figure and axes fig, ax = plt.subplots(1, 1, figsize=(9, 9)) # configure axes ax.set_aspect("equal") ax.set_xbound(-2, 2) ax.set_ybound(-2, 2) angles = distributions.StaticUniformAngularDistribution(-PI/4.0, PI/4.0, 5) source = sources.PointSource((0.0, 0.0), 0.0, angles, [drawing.YELLOW]) engine = eng.OpticalEngine(2, [op.OldestAncestor(), op.StandardReaction()]) system = eng.OpticalSystem2D() system.sources = [source] system.update() # set up drawer drawer = drawing.RayDrawer2D(ax) drawer.rays = source drawer.draw() # hand over to user fig.canvas.mpl_connect( "key_press_event", lambda event: on_key(event, drawer, source, system),
import tfrt.engine as engine import tfrt.materials as materials import tfrt.boundaries as boundaries import tfrt.operation as operation PI = tf.constant(math.pi, dtype=tf.float64) sample_count = 1000 angular_cutoff = PI / 2 plot = pv.Plotter() plot.add_axes() # build and draw the source visual_dist = distributions.SquareRankLambertianSphere(sample_count, angular_cutoff) visual_source = sources.PointSource(3, (5, 0, 0), (0, 0, 1), visual_dist, [drawing.YELLOW]) test_dist = distributions.SquareRankLambertianSphere(1000 * sample_count, angular_cutoff) test_source = sources.PointSource(3, (5, 0, 0), (0, 0, 1), test_dist, [drawing.YELLOW]) ray_drawer = drawing.RayDrawer3D(plot, visual_source) ray_drawer.draw() # draw the ranks and circle points, with lines between them, showing the square-circle # transformation fake_rays = { "x_start": visual_dist.ranks[:, 0], "y_start": visual_dist.ranks[:, 1], "z_start": tf.zeros((sample_count, ), dtype=tf.float64),
) focal_plane = np.array([[ -max_target_size, -height, max_target_size, -height ], [ -2.0 * max_target_size, -height, -max_target_size, 10.0 * max_target_size ], [max_target_size, -height, 2.0 * max_target_size, 10.0 * max_target_size]], dtype=np.float64) # build the source angular_distribution = sources.StaticLambertianAngularDistribution( -source_angular_cutoff, source_angular_cutoff, ray_count) central_angle_placeholder = tf.placeholder(tf.float64, name="central_angle_placeholder") source = sources.PointSource((0.0, 0.0), central_angle_placeholder, angular_distribution, [drawing.YELLOW], ray_length=10.0) def polynomial(name, max_order, min_order=0, dtype=tf.float64): """ Generates a parametrized polynomial, for use in interpolating stuff. Automatically creates a tf variable to store its parametrization. x : float tensor The independant variable used to evaluate the polynomial. max_order : int The maximum power used in the polynomial. min_order : int The minumum power used in the polynomial.
import tfrt.distributions as dist import tfrt.sources as sources d = dist.StaticUniformAngularDistribution(-1, 1, 3) s = sources.PointSource(2, (0, 0), 0, d, [.5, .6, .7], dense=True, rank_source=("angle", "ranks")) print(f"source._ranks: {s._ranks}") print(f"source[ranks]: {s['ranks']}")
import matplotlib as mpl import matplotlib.pyplot as plt import tensorflow as tf import math import tfrt.distributions as distributions import tfrt.sources as sources import tfrt.drawing as drawing import tfrt.engine as eng import tfrt.operation as op PI = math.pi a1 = distributions.StaticUniformAngularDistribution(-PI/4.0, PI/4.0, 5) s1 = sources.PointSource((0.0, 0.0), 0.0, a1, [drawing.YELLOW]) a2 = distributions.StaticUniformAngularDistribution(-PI/4.0, PI/4.0, 1) s2 = sources.PointSource((0.0, 1.0), 0.0, a2, [drawing.YELLOW]) a3 = distributions.StaticUniformAngularDistribution(-PI/4.0, PI/4.0, 7) s3 = sources.PointSource((0.0, 2.0), 0.0, a3, [drawing.YELLOW]) engine = eng.OpticalEngine(2, [op.OldestAncestor()]) system = eng.OpticalSystem2D() engine.optical_system = system system.sources = [s1, s2, s3] engine.annotate() engine.update() print(f"system validation:") engine.validate_system()
import tfrt.sources as sources import tfrt.distributions as distributions import tfrt.drawing as drawing import tfrt.boundaries as boundaries import tfrt.engine as engine import tfrt.operation as operation import tfrt.materials as materials import tfrt.graph as graph PI = tf.constant(pi, dtype=tf.float64) # build the source rays angles = distributions.ManualAngularDistribution([(1, 0, 0)]) source = sources.PointSource(3, (-5, 0, 0), (1, 0, 0), angles, [drawing.YELLOW], dense=False, rank_type=None) # build the boundaries zero_points = pv.PolyData(np.array([(0, 0, 1), (0, -1, -1), (0, 1, -1)]), np.array([3, 0, 1, 2])) # do the mesh tricks top_parent = graph.get_closest_point(zero_points, (0, 0, 0)) vertex_update_map, accumulator = graph.mesh_parametrization_tools( zero_points, top_parent) print(f"accumulator: {accumulator}") print(f"vertex update map: {vertex_update_map}") vg = boundaries.FromVectorVG((1, 0, 0))
def plot_angle_test(session, ax, x, angle): # generate and draw the starting rays ray_count = 11 angular_distribution = sources.StaticUniformAngularDistribution( -0.9 * PI / 2.0, 0.9 * PI / 2.0, ray_count ) wavelengths = np.linspace(drawing.VISIBLE_MIN, drawing.VISIBLE_MAX, ray_count) external_rays = sources.PointSource( (x, 0.25), angle, angular_distribution, wavelengths, start_on_center=False, dense=False, ray_length=0.1, ) external_drawer = drawing.RayDrawer(ax, rays=session.run(external_rays.rays)) external_drawer.draw() internal_rays = sources.PointSource( (x, -0.25), angle + PI, angular_distribution, wavelengths, start_on_center=False, dense=False, ray_length=0.1, ) internal_drawer = drawing.RayDrawer(ax, rays=session.run(internal_rays.rays)) internal_drawer.draw() # generate and draw the boundary segment_length = 0.2 segment_angle = angle + PI / 2.0 segments = np.array( [ [ x + segment_length * math.cos(segment_angle), 0.25 + segment_length * math.sin(segment_angle), x - segment_length * math.cos(segment_angle), 0.25 - segment_length * math.sin(segment_angle), ], [ x + segment_length * math.cos(segment_angle), -0.25 + segment_length * math.sin(segment_angle), x - segment_length * math.cos(segment_angle), -0.25 - segment_length * math.sin(segment_angle), ], ] ) segment_drawer = drawing.SegmentDrawer( ax, segments=segments, color=(0, 1, 1), draw_norm_arrows=True ) segment_drawer.draw() # react the rays and draw the reactions n_in = tf.cast(1.5, tf.float64) n_out = tf.cast(1.0, tf.float64) angle = tf.cast(angle, tf.float64) external_reacted = geometry.ray_reaction( external_rays.rays, angle, n_in, n_out, new_ray_length=0.2 ) ex_reacted_drawer = drawing.RayDrawer( ax, rays=session.run(external_reacted), style="--" ) ex_reacted_drawer.draw() internal_reacted = geometry.ray_reaction( internal_rays.rays, angle, n_in, n_out, new_ray_length=0.2 ) in_reacted_drawer = drawing.RayDrawer( ax, rays=session.run(internal_reacted), style="--" ) in_reacted_drawer.draw()
angular_distribution, base_point_distribution, drawing.RAINBOW_6, name="AngularSource", dense=True, start_on_base=True, ray_length=1.0, ) angles_2 = distributions.RandomUniformAngularDistribution( -PI / 4.0, PI / 4.0, 6, name="StaticUniformAngularDistribution" ) fixed_source = sources.PointSource( [-1.0, 0.0], PI, angles_2, drawing.RAINBOW_6, dense=False ) optical_system = engine.OpticalSystem2D() optical_system.sources = [movable_source, fixed_source] optical_system.update() """# Make an optical surface, so we can check that the rays are oriented # correctly segment_boundary = np.array([[1, -2, 1, 2, 1, 0]], dtype=np.float64) material_list = [materials.vacuum, materials.acrylic] # Make a ray tracer. Concat all the ray types into traced_rays, for ease of # use