//---------------------------------------------------------------------------
float CalculateRules2(float hue, float saturation, float value, int color)
{ float ret_val,lower_sum=0;
int RulesCounter=0;
while (fuzzy_rules[RulesCounter].hue>=0)
{ /*
if (do_grey_scale || (strcmp(fuzzy_rules[RulesCounter].color,"white")
&& strcmp(fuzzy_rules[RulesCounter].color,"light_grey")
&& strcmp(fuzzy_rules[RulesCounter].color,"dark_grey")
&& strcmp(fuzzy_rules[RulesCounter].color,"black")))
{
*/
if (fuzzy_rules[RulesCounter].color==color) /* calculate only rules of the same color */
{ /* hue functions */
ret_val=color_value(fuzzy_rules[RulesCounter].hue,hue);
if (ret_val==0) goto loop;
/* saturation function */
if (fuzzy_rules[RulesCounter].saturation==SATURATION_GREY) ret_val=ret_val*grey_value(saturation);
if (fuzzy_rules[RulesCounter].saturation==SATURATION_ALMOST_GREY) ret_val=ret_val*almost_grey_value(saturation);
if (fuzzy_rules[RulesCounter].saturation==SATURATION_TEND_GREY) ret_val=ret_val*tend_grey_value(saturation);
if (fuzzy_rules[RulesCounter].saturation==SATURATION_MEDIUM_GREY) ret_val=ret_val*medium_grey_value(saturation);
if (fuzzy_rules[RulesCounter].saturation==SATURATION_TEND_CLEAR) ret_val=ret_val*tend_clear_value(saturation);
if (fuzzy_rules[RulesCounter].saturation==SATURATION_CLEAR) ret_val=ret_val*clear_value(saturation);
if (ret_val==0) goto loop;
/* value functions */
if (fuzzy_rules[RulesCounter].value==VALUE_DARK) ret_val=ret_val*dark_value(value);
if (fuzzy_rules[RulesCounter].value==VALUE_ALMOST_DARK) ret_val=ret_val*almost_dark_value(value);
if (fuzzy_rules[RulesCounter].value==VALUE_TEND_DARK) ret_val=ret_val*tend_dark_value(value);
if (fuzzy_rules[RulesCounter].value==VALUE_TEND_LIGHT) ret_val=ret_val*tend_light_value(value);
if (fuzzy_rules[RulesCounter].value==VALUE_LIGHT) ret_val=ret_val*light_value(value);
/* add the rule values */
lower_sum=lower_sum+ret_val;
}
loop:
RulesCounter++;
}
return(lower_sum);
}
void DirectLightingIntegrator::add_non_physical_light_sample_contribution(
SamplingContext& sampling_context,
const LightSample& sample,
const Dual3d& outgoing,
DirectShadingComponents& radiance,
LightPathStream* light_path_stream) const
{
const Light* light = sample.m_light;
// No contribution if we are computing indirect lighting but this light does not cast indirect light.
if (m_indirect && !(light->get_flags() & Light::CastIndirectLight))
return;
// Generate a uniform sample in [0,1)^2.
SamplingContext child_sampling_context = sampling_context.split(2, 1);
const Vector2d s = child_sampling_context.next2<Vector2d>();
// Evaluate the light.
Vector3d emission_position, emission_direction;
Spectrum light_value(Spectrum::Illuminance);
float probability;
light->sample(
m_shading_context,
sample.m_light_transform,
m_material_sampler.get_point(),
s,
emission_position,
emission_direction,
light_value,
probability);
// Compute the incoming direction in world space.
const Vector3d incoming = -emission_direction;
// Compute the transmission factor between the light sample and the shading point.
Spectrum transmission;
m_material_sampler.trace_between(
m_shading_context,
emission_position,
transmission);
// Discard occluded samples.
if (is_zero(transmission))
return;
// Evaluate the BSDF (or volume).
DirectShadingComponents material_value;
const float material_probability =
m_material_sampler.evaluate(
Vector3f(outgoing.get_value()),
Vector3f(incoming),
m_light_sampling_modes,
material_value);
assert(material_probability >= 0.0f);
if (material_probability == 0.0f)
return;
// Add the contribution of this sample to the illumination.
const float attenuation = light->compute_distance_attenuation(
m_material_sampler.get_point(), emission_position);
light_value *= transmission;
light_value *= attenuation / (sample.m_probability * probability);
madd(radiance, material_value, light_value);
// Record light path event.
if (light_path_stream)
{
light_path_stream->sampled_non_physical_light(
*light,
emission_position,
material_value.m_beauty,
light_value);
}
}
