/**
* 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();
}
