/** * Draw all tangential rays using specified renderer. Only rays * which end up hitting the image plane are drawn when @tt * hit_image is set. */ public static void draw_2d(Renderer r, RayTraceResults result, bool hit_image /*= false*/, Element ref_ /* = null */) { r.group_begin("rays"); draw_trace_result2d(r, result, ref_, hit_image); r.group_end(); }
List <TracedRay> process_rays(Surface surface, TraceIntensityMode m, RayTraceResults result, List <TracedRay> input) { RayTraceParameters params_ = result._parameters; List <TracedRay> rays = new(); foreach (TracedRay i in input) { TracedRay ray = i; Transform3 t = ray.get_creator().get_transform_to(surface); Vector3Pair local1 = t.transform_line(ray.get_ray()); Vector3Pair pt = surface is Stop ? intersect((Stop)surface, params_, local1) : intersect(surface, params_, local1); if (pt != null) { result.add_intercepted(surface, ray); TracedRay cray = trace_ray(surface, m, result, ray, local1, pt); if (cray != null) { rays.Add(cray); } } } return(rays); }
private static void draw_trace_result2d(Renderer renderer, RayTraceResults result, Element ref_, bool hit_image) { List <RaySource> sl = result.get_source_list(); double lost_len = result.get_params().get_lost_ray_length(); if (sl.Count == 0) { throw new InvalidOperationException("No source found in trace result"); } double max_intensity = result.get_max_ray_intensity(); foreach (RaySource s in sl) { try { List <TracedRay> rl = result.get_generated(s); foreach (TracedRay ray in rl) { renderer.group_begin("ray"); draw_traced_ray_recurs(renderer, ray, lost_len, ref_, hit_image, 2, false); renderer.group_end(); } } catch (Exception) { // FIXME e.printStackTrace(); } } }
public List <TracedRay> generate_rays_simple(RayTraceResults result, RayTraceParameters parameters, PointSource source, List <Element> targets) { List <TracedRay> rays = new(); foreach (Element target in targets) { rays.AddRange(generate_rays(result, parameters, source, target, source.mode())); } return(rays); }
private List <TracedRay> process_rays_simple(Element e, RayTraceResults result, List <TracedRay> input) { switch (e) { case Stop surface: return(process_rays(surface, TraceIntensityMode.Simpletrace, result, input)); case Surface surface: return(process_rays(surface, TraceIntensityMode.Simpletrace, result, input)); default: throw new InvalidOperationException(); } }
public void trace() { if (_processed_trace) { return; } _image = (Image)(from p in _params.get_sequence() where p is Image select p as Image).First(); _results = _tracer.trace(_system, _params); _intercepts = _results.get_intercepted(_image); _processed_trace = true; }
List <TracedRay> process_rays(Element e, TraceIntensityMode m, RayTraceResults result, List <TracedRay> input) { switch (m) { case TraceIntensityMode.Simpletrace: return(process_rays_simple(e, result, input)); case TraceIntensityMode.Intensitytrace: return(process_rays_intensity(e, result, input)); case TraceIntensityMode.Polarizedtrace: return(process_rays_polarized(e, result, input)); } return(new()); }
private TracedRay trace_ray_simple(Surface surface, RayTraceResults result, TracedRay incident, Vector3Pair local, Vector3Pair pt) { if (surface is OpticalSurface) { return(trace_ray_simple((OpticalSurface)surface, result, incident, local, pt)); } else if (surface is Stop) { return(trace_ray_simple((Stop)surface, result, incident, local, pt)); } else { return(null); } }
TracedRay trace_ray(Surface surface, TraceIntensityMode m, RayTraceResults result, TracedRay incident, Vector3Pair local, Vector3Pair pt) { incident.set_len((pt.origin().minus(local.origin())).len()); incident.set_intercept(surface, pt.origin()); if (m == TraceIntensityMode.Simpletrace) { incident.set_intercept_intensity(1.0); return(trace_ray_simple(surface, result, incident, local, pt)); } else { // apply absorbtion from current material double i_intensity = incident.get_intensity() * incident.get_material().get_internal_transmittance( incident.get_wavelen(), incident.get_len()); incident.set_intercept_intensity(i_intensity); // FIXME // if (i_intensity < _discard_intensity) // return; if (m == TraceIntensityMode.Intensitytrace) { return(trace_ray_intensity(surface, result, incident, local, pt)); } else if (m == TraceIntensityMode.Polarizedtrace) { return(trace_ray_polarized(surface, result, incident, local, pt)); } else { throw new InvalidOperationException(); } } }
TracedRay trace_ray_simple(Stop surface, RayTraceResults result, TracedRay incident, Vector3Pair local, Vector3Pair intersect) { Vector2 v = intersect.origin().project_xy(); bool ir = true; // FIXME _intercept_reemit || result.get_params ().is_sequential (); if (ir && surface.get_shape().inside(v)) { // re-emit incident ray TracedRay r = result.newRay(intersect.origin(), incident.get_ray().direction()); r.set_wavelen(incident.get_wavelen()); r.set_intensity(incident.get_intensity()); r.set_material(incident.get_material()); r.set_creator(surface); incident.add_generated(r); return(r); } return(null); }
public RayTraceResults trace(OpticalSystem system, RayTraceParameters parameters) { RayTraceResults result = new RayTraceResults(parameters); switch (parameters._intensity_mode) { case TraceIntensityMode.Simpletrace: if (!parameters._sequential_mode) { //trace_template<Simpletrace> (); throw new InvalidOperationException(); } else { trace_sequential(parameters._intensity_mode, parameters, result); } break; case TraceIntensityMode.Intensitytrace: // if (!parameters._sequential_mode) // trace_template<Intensitytrace> (); // else // trace_seq_template<Intensitytrace> (); throw new InvalidOperationException(); //break; case TraceIntensityMode.Polarizedtrace: // if (!parameters._sequential_mode) // trace_template<Polarizedtrace> (); // else // trace_seq_template<Polarizedtrace> (); throw new InvalidOperationException(); //break; } return(result); }
List <TracedRay> process_rays(Stop surface, TraceIntensityMode m, RayTraceResults result, List <TracedRay> input) { List <TracedRay> rays = new(); foreach (TracedRay i in input) { TracedRay ray = i; Transform3 t = ray.get_creator().get_transform_to(surface); Vector3Pair local = t.transform_line(ray.get_ray()); Vector3 origin = surface.get_curve().intersect(local); if (origin != null) { if (origin.project_xy().len() < surface.get_external_radius()) { Vector3 normal = surface.get_curve().normal(origin); if (local.direction().z() < 0) { normal = normal.negate(); } result.add_intercepted(surface, ray); TracedRay cray = trace_ray(surface, m, result, ray, local, new Vector3Pair(origin, normal)); if (cray != null) { rays.Add(cray); } } } } return(rays); }
List <TracedRay> generate_rays( RayTraceResults result, RayTraceParameters parameters, PointSource source, Element target, PointSource.SourceInfinityMode mode) { if (!(target is OpticalSurface)) { return(new()); } OpticalSurface target_surface = (OpticalSurface)target; double rlen = parameters.get_lost_ray_length(); Distribution d = parameters.get_distribution(target_surface); List <TracedRay> rays = new(); ConsumerVector3 de = (Vector3 v) => { Vector3 r = target_surface.get_transform_to(source).transform(v); // pattern point on target surface Vector3 direction; Vector3 position; switch (mode) { case PointSource.SourceInfinityMode.SourceAtFiniteDistance: position = Vector3.vector3_0; direction = r.normalize(); break; default: case PointSource.SourceInfinityMode.SourceAtInfinity: direction = Vector3.vector3_001; position = new Vector3Pair( target_surface.get_position(source).minus(Vector3.vector3_001.times(rlen)), Vector3.vector3_001) .pl_ln_intersect(new Vector3Pair(r, direction)); break; } foreach (SpectralLine l in source.spectrum()) { // generated rays use source coordinates TracedRay ray = result.newRay(position, direction); ray.set_creator(source); ray.set_intensity(l.get_intensity()); // FIXME depends on distance from // source and pattern density ray.set_wavelen(l.get_wavelen()); Medium material = source.get_material(); if (material == null) { material = Air.air; // FIXME centralize as env - original uses env proxy. } ray.set_material(material); rays.Add(ray); } }; target_surface.get_pattern(de, d, parameters.get_unobstructed()); return(rays); }
static void Main(string[] args) { Args arguments = Args.parseArguments(args); if (arguments.filename == null) { Console.WriteLine("Usage: --specfile inputfile [--scenario num] [--skew] [--output layout|spot] [--dump-system]"); Environment.Exit(1); } OpticalBenchDataImporter.LensSpecifications specs = new OpticalBenchDataImporter.LensSpecifications(); specs.parse_file(arguments.filename); OpticalSystem.Builder systemBuilder = OpticalBenchDataImporter.buildSystem(specs, arguments.scenario); double angleOfView = OpticalBenchDataImporter.getAngleOfViewInRadians(specs, arguments.scenario); Vector3 direction = Vector3.vector3_001; if (arguments.skewRays) { // Construct unit vector at an angle // double z1 = cos (angleOfView); // double y1 = sin (angleOfView); // unit_vector = math::Vector3 (0, y1, z1); Matrix3 r = Matrix3.get_rotation_matrix(0, angleOfView); direction = r.times(direction); } PointSource.Builder ps = new PointSource.Builder(PointSource.SourceInfinityMode.SourceAtInfinity, direction) .add_spectral_line(SpectralLine.d) .add_spectral_line(SpectralLine.C) .add_spectral_line(SpectralLine.F); systemBuilder.add(ps); OpticalSystem system = systemBuilder.build(); if (arguments.dumpSystem) { Console.WriteLine(system); } if (arguments.outputType.Equals("layout")) { RendererSvg renderer = new RendererSvg(800, 400); // draw 2d system layout SystemLayout2D systemLayout2D = new SystemLayout2D(); systemLayout2D.layout2d(renderer, system); RayTraceParameters parameters = new RayTraceParameters(system); RayTracer rayTracer = new RayTracer(); parameters.set_default_distribution( new Distribution(Pattern.MeridionalDist, 10, 0.999)); // TODO set save generated state on point source if (arguments.dumpSystem) { Console.WriteLine(parameters.sequenceToString(new StringBuilder()).ToString()); } RayTraceResults result = rayTracer.trace(system, parameters); RayTraceRenderer.draw_2d(renderer, result, false, null); Console.WriteLine(renderer.write(new StringBuilder()).ToString()); } if (arguments.outputType.Equals("spot")) { RendererSvg renderer = new RendererSvg(300, 300, Rgb.rgb_black); renderer = new RendererSvg(300, 300, Rgb.rgb_black); AnalysisSpot spot = new AnalysisSpot(system); spot.draw_diagram(renderer, true); Console.WriteLine(renderer.write(new StringBuilder()).ToString()); } }
void trace_sequential(RayTracer.TraceIntensityMode m, RayTraceParameters parameters, RayTraceResults result) { // stack of rays to propagate RayCollection[] tmp = new[] { new RayCollection(), new RayCollection() }; RayGenerator rayGenerator = new RayGenerator(); int swaped = 0; List <TracedRay> generated; List <TracedRay> source_rays = tmp[1].rays; List <Element> seq = parameters._sequence; Element entrance = null; // find entry element (first non source) for (int i = 0; i < seq.Count; i++) { if (!(seq[i] is RaySource)) { entrance = seq[i]; break; } } for (int i = 0; i < seq.Count; i++) { Element element = seq[i]; // if (!element->is_enabled ()) // continue; RayTraceResults.RaysAtElement er = result.get_element_result(element); generated = er._generated != null ? er._generated : tmp[swaped].rays; generated.Clear(); switch (element) { case PointSource source: { result.add_source(source); List <Element> elist = new(); if (entrance != null) { elist.Add(entrance); } List <TracedRay> rays = rayGenerator.generate_rays_simple(result, parameters, source, elist); generated.AddRange(rays); break; } default: { List <TracedRay> rays = process_rays(element, m, result, source_rays); // swap ray buffers generated.AddRange(rays); break; } } source_rays = generated; swaped ^= 1; } }
private TracedRay trace_ray_simple(OpticalSurface surface, RayTraceResults result, TracedRay incident, Vector3Pair local, Vector3Pair intersect) { bool right_to_left = intersect.normal().z() > 0; Medium prev_mat = surface.get_material(right_to_left ? 1 : 0); Medium next_mat = surface.get_material(!right_to_left ? 1 : 0); // check ray didn't "escaped" from its material // std::cout << prev_mat->name << " " << next_mat->name << // " " << incident.get_material()->name << std::endl; if (prev_mat != incident.get_material()) { return(null); } double wl = incident.get_wavelen(); double index = prev_mat.get_refractive_index(wl) / next_mat.get_refractive_index(wl); // refracted ray direction Vector3 direction = refract(surface, local, intersect.normal(), index); if (direction == null) { // total internal reflection Vector3 o = intersect.origin(); Vector3 dir = reflect(surface, local, intersect.normal()); TracedRay r = result.newRay(o, dir); r.set_wavelen(wl); r.set_intensity(incident.get_intensity()); r.set_material(prev_mat); r.set_creator(surface); incident.add_generated(r); return(r); } // transmit if (!next_mat.is_opaque()) { Vector3 o = intersect.origin(); TracedRay r = result.newRay(o, direction); r.set_wavelen(wl); r.set_intensity(incident.get_intensity()); r.set_material(next_mat); r.set_creator(surface); incident.add_generated(r); return(r); } // reflect if (next_mat.is_reflecting()) { Vector3 o = intersect.origin(); Vector3 dir = reflect(surface, local, intersect.normal()); TracedRay r = result.newRay(o, dir); r.set_wavelen(wl); r.set_intensity(incident.get_intensity()); r.set_material(prev_mat); r.set_creator(surface); incident.add_generated(r); return(r); } return(null); }
private TracedRay trace_ray_intensity(Surface surface, RayTraceResults result, TracedRay incident, Vector3Pair local, Vector3Pair pt) { throw new InvalidOperationException(); }
private List <TracedRay> process_rays_intensity(Element e, RayTraceResults result, List <TracedRay> input) { throw new InvalidOperationException(); }