示例#1
0
        public override double get_refractive_index(double wavelen)
        {
            if (wavelen == _last_wavelen)
            {
                return(_last_get_refractive_index);
            }

            double a = _measurement_medium.get_refractive_index(wavelen);
            double m = get_measurement_index(wavelen);

            // get absolute refractive index
            double n = m * a;

            // apply temperature coefficients
            switch (_temp_model)
            {
            case thermal_model_e.ThermalSchott:
                n = n + get_schott_temp(wavelen, m);
                break;

            case thermal_model_e.ThermalDnDt: {
                double dt = _temperature - _measurement_medium.get_temperature();
                n = n + dt * _temp_d0;
                break;
            }

            case thermal_model_e.ThermalNone:
                break;
            }

            _last_wavelen = wavelen;
            _last_get_refractive_index = n;

            return(n);
        }
示例#2
0
        /** Get transmittance at normal incidence */
        public virtual double get_normal_transmittance(Medium from,
                                                       double wavelen)
        {
            // default transmittance at normal incidence, valid for non absorbing material
            // McGraw Hill, Handbook of optics, vol1, 1995, 5-8 (23)

            double n0 = from.get_refractive_index(wavelen);
            double n1 = get_refractive_index(wavelen);

            return((4.0 * n0 * n1) / MathUtils.square(n0 + n1));
        }
示例#3
0
        /** Get reflectance at normal incidence */
        public virtual double get_normal_reflectance(Medium from,
                                                     double wavelen)
        {
            // default reflectance at normal incidence, valid for metal and dielectric
            // material
            // McGraw Hill, Handbook of optics, vol1, 1995, 5-10 (47)

            double n0  = from.get_refractive_index(wavelen);
            double k12 = MathUtils.square(get_extinction_coef(wavelen));
            double n1  = get_refractive_index(wavelen);
            double res = (MathUtils.square(n0 - n1) + k12) / (MathUtils.square(n0 + n1) + k12);

            return(res);
        }
示例#4
0
        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);
        }
示例#5
0
 /** Get material relative refractive index in given medium at specified
  * wavelen in @em nm. */
 public virtual double get_refractive_index(double wavelen, Medium env)
 {
     return(get_refractive_index(wavelen) / env.get_refractive_index(wavelen));
 }