// Returns the area of black color captured of a certain image.
int NaoVision::getAreaBlackColor(Mat originalImage) {
iLowH = 0;
iHighH = 180;
iLowS = 0;
iHighS = 255;
iLowV = 100;
iHighV = 255;
ColorFilter(originalImage);
areaColorDetection = 195 - areaColorDetection;
cout << areaColorDetection << endl;
return areaColorDetection;
}
// Returns the area of yellow color captured of a certain image.
int NaoVision::getAreaYellowColor(Mat originalImage) {
/*Parametros de Cinta Amarilla
* LowH = 020/179
* HighH = 071/179
* LowS = 169/255
* HighS = 255/255
* LowV = 141/255
* HighV = 255/255
*/
iLowH = 20;
iHighH = 100;
iLowS = 80;
iHighS = 255;
iLowV = 141;
iHighV = 255;
ColorFilter(originalImage);
return areaColorDetection;
}
// Returns the area of red color captured of a certain image.
int NaoVision::getAreaRedColor(Mat originalImage) {
/*Parametros de Cinta Rojo
* LowH = 160/179
* HighH = 179/179
* LowS = 100/255
* HighS = 255/255
* LowV = 100/255
* HighV = 255/255
*/
iLowH = 160;
iHighH = 179;
iLowS = 0;
iHighS = 255;
iLowV = 0;
iHighV = 255;
//calibrateColorDetection();
ColorFilter(originalImage);
return areaColorDetection;
}
/*
* @brief Applies brightness, contrast and saturation to the specified image
* while optionally computing the average color. Also handles image inversion
* and monochrome. This is all munged into one function for performance.
*/
void R_FilterImage(r_image_t *image, GLenum format, byte *data) {
vec_t brightness;
uint32_t color[3];
uint16_t mask;
size_t i, j;
if (image->type == IT_DIFFUSE) {// compute average color
VectorClear(color);
}
if (image->type == IT_LIGHTMAP) {
brightness = r_modulate->value;
mask = 2;
} else {
brightness = r_brightness->value;
mask = 1;
}
const size_t pixels = image->width * image->height;
const size_t stride = format == GL_RGBA ? 4 : 3;
byte *p = data;
for (i = 0; i < pixels; i++, p += stride) {
vec3_t temp;
VectorScale(p, 1.0 / 255.0, temp); // convert to float
// apply brightness, saturation and contrast
ColorFilter(temp, temp, brightness, r_saturation->value, r_contrast->value);
for (j = 0; j < 3; j++) {
temp[j] = Clamp(temp[j] * 255, 0, 255); // back to byte
p[j] = (byte) temp[j];
if (image->type == IT_DIFFUSE) // accumulate color
color[j] += p[j];
}
if (r_monochrome->integer & mask) // monochrome
p[0] = p[1] = p[2] = (p[0] + p[1] + p[2]) / 3;
if (r_invert->integer & mask) { // inverted
p[0] = 255 - p[0];
p[1] = 255 - p[1];
p[2] = 255 - p[2];
}
}
if (image->type == IT_DIFFUSE) { // average accumulated colors
for (i = 0; i < 3; i++)
color[i] /= (vec_t) pixels;
if (r_monochrome->integer & mask)
color[0] = color[1] = color[2] = (color[0] + color[1] + color[2]) / 3.0;
if (r_invert->integer & mask) {
color[0] = 255 - color[0];
color[1] = 255 - color[1];
color[2] = 255 - color[2];
}
for (i = 0; i < 3; i++)
image->color[i] = color[i] / 255.0;
}
}
/*
* R_ResolveBspLightParameters
*
* Resolves ambient light, brightness, and contrast levels from Worldspawn.
*/
static void R_ResolveBspLightParameters(void) {
const char *c;
// resolve ambient light
if ((c = R_WorldspawnValue("ambient_light"))) {
sscanf(c, "%f %f %f", &r_locals.ambient_light[0],
&r_locals.ambient_light[1], &r_locals.ambient_light[2]);
VectorScale(r_locals.ambient_light, BSP_LIGHT_AMBIENT_SCALE, r_locals.ambient_light);
Com_Debug("Resolved ambient_light: %1.2f %1.2f %1.2f\n",
r_locals.ambient_light[0], r_locals.ambient_light[1],
r_locals.ambient_light[2]);
} else { // ensure sane default
VectorSet(r_locals.ambient_light, 0.1, 0.1, 0.1);
}
// resolve sun light
if ((c = R_WorldspawnValue("sun_light"))) {
r_locals.sun_light = atof(c) / 255.0;
if (r_locals.sun_light > 1.0) // should never happen
r_locals.sun_light = 1.0;
Com_Debug("Resolved sun_light: %1.2f\n", r_locals.sun_light);
} else {
r_locals.sun_light = 0.0;
}
// resolve sun color
if ((c = R_WorldspawnValue("sun_color"))) {
sscanf(c, "%f %f %f", &r_locals.sun_color[0], &r_locals.sun_color[1],
&r_locals.sun_color[2]);
Com_Debug("Resolved sun_color: %1.2f %1.2f %1.2f\n",
r_locals.sun_color[0], r_locals.sun_color[1],
r_locals.sun_color[2]);
} else { // ensure sane default
VectorSet(r_locals.sun_color, 1.0, 1.0, 1.0);
}
// resolve brightness
if ((c = R_WorldspawnValue("brightness"))) {
r_locals.brightness = atof(c);
} else { // ensure sane default
r_locals.brightness = 1.0;
}
// resolve saturation
if ((c = R_WorldspawnValue("saturation"))) {
r_locals.saturation = atof(c);
} else { // ensure sane default
r_locals.saturation = 1.0;
}
// resolve contrast
if ((c = R_WorldspawnValue("contrast"))) {
r_locals.contrast = atof(c);
} else { // ensure sane default
r_locals.contrast = 1.0;
}
Com_Debug("Resolved brightness: %1.2f\n", r_locals.brightness);
Com_Debug("Resolved saturation: %1.2f\n", r_locals.saturation);
Com_Debug("Resolved contrast: %1.2f\n", r_locals.contrast);
#if 0
//apply brightness, saturation and contrast to the colors
ColorFilter(r_locals.ambient_light, r_locals.ambient_light,
r_locals.brightness, r_locals.saturation, r_locals.contrast);
Com_Debug("Scaled ambient_light: %1.2f %1.2f %1.2f\n",
r_locals.ambient_light[0], r_locals.ambient_light[1], r_locals.ambient_light[2]);
ColorFilter(r_locals.sun_color, r_locals.sun_color,
r_locals.brightness, r_locals.saturation, r_locals.contrast);
Com_Debug("Scaled sun_color: %1.2f %1.2f %1.2f\n",
r_locals.sun_color[0], r_locals.sun_color[1], r_locals.sun_color[2]);
#endif
}
/**
* @brief Resolves ambient light, brightness, and contrast levels from Worldspawn.
*/
static void R_ResolveBspLightParameters(void) {
const char *c;
vec3_t tmp;
// resolve ambient light
if ((c = Cm_WorldspawnValue("ambient"))) {
vec_t *f = r_bsp_light_state.ambient;
sscanf(c, "%f %f %f", &f[0], &f[1], &f[2]);
VectorScale(f, r_modulate->value, f);
Com_Debug(DEBUG_RENDERER, "Resolved ambient: %s\n", vtos(f));
} else {
VectorSet(r_bsp_light_state.ambient, 0.15, 0.15, 0.15);
}
// resolve sun light
if ((c = Cm_WorldspawnValue("sun_light"))) {
r_bsp_light_state.sun.diffuse = atof(c) * BSP_LIGHT_SUN_SCALE;
Com_Debug(DEBUG_RENDERER, "Resolved sun_light: %1.2f\n", r_bsp_light_state.sun.diffuse);
} else {
r_bsp_light_state.sun.diffuse = 0.0;
}
// resolve sun angles and direction
if ((c = Cm_WorldspawnValue("sun_angles"))) {
VectorClear(tmp);
sscanf(c, "%f %f", &tmp[0], &tmp[1]);
Com_Debug(DEBUG_RENDERER, "Resolved sun_angles: %s\n", vtos(tmp));
AngleVectors(tmp, r_bsp_light_state.sun.dir, NULL, NULL);
} else {
VectorCopy(vec3_down, r_bsp_light_state.sun.dir);
}
// resolve sun color
if ((c = Cm_WorldspawnValue("sun_color"))) {
vec_t *f = r_bsp_light_state.sun.color;
sscanf(c, "%f %f %f", &f[0], &f[1], &f[2]);
Com_Debug(DEBUG_RENDERER, "Resolved sun_color: %s\n", vtos(f));
} else {
VectorSet(r_bsp_light_state.sun.color, 1.0, 1.0, 1.0);
}
// resolve brightness
if ((c = Cm_WorldspawnValue("brightness"))) {
r_bsp_light_state.brightness = atof(c);
} else {
r_bsp_light_state.brightness = 1.0;
}
// resolve saturation
if ((c = Cm_WorldspawnValue("saturation"))) {
r_bsp_light_state.saturation = atof(c);
} else {
r_bsp_light_state.saturation = 1.0;
}
// resolve contrast
if ((c = Cm_WorldspawnValue("contrast"))) {
r_bsp_light_state.contrast = atof(c);
} else {
r_bsp_light_state.contrast = 1.0;
}
Com_Debug(DEBUG_RENDERER, "Resolved brightness: %1.2f\n", r_bsp_light_state.brightness);
Com_Debug(DEBUG_RENDERER, "Resolved saturation: %1.2f\n", r_bsp_light_state.saturation);
Com_Debug(DEBUG_RENDERER, "Resolved contrast: %1.2f\n", r_bsp_light_state.contrast);
const vec_t brt = r_bsp_light_state.brightness;
const vec_t sat = r_bsp_light_state.saturation;
const vec_t con = r_bsp_light_state.contrast;
// apply brightness, saturation and contrast to the colors
ColorFilter(r_bsp_light_state.ambient, r_bsp_light_state.ambient, brt, sat, con);
Com_Debug(DEBUG_RENDERER, "Scaled ambient: %s\n", vtos(r_bsp_light_state.ambient));
ColorFilter(r_bsp_light_state.sun.color, r_bsp_light_state.sun.color, brt, sat, con);
Com_Debug(DEBUG_RENDERER, "Scaled sun color: %s\n", vtos(r_bsp_light_state.sun.color));
}
/**
* @brief Parse the entity string and resolve all static light sources. Sources which
* are very close to each other are merged. Their colors are blended according
* to their light value (intensity).
*/
void R_LoadBspLights(r_bsp_model_t *bsp) {
vec3_t origin, color;
vec_t radius;
memset(&r_bsp_light_state, 0, sizeof(r_bsp_light_state));
const r_bsp_light_state_t *s = &r_bsp_light_state;
R_ResolveBspLightParameters();
// iterate the world surfaces for surface lights
const r_bsp_surface_t *surf = bsp->surfaces;
for (uint16_t i = 0; i < bsp->num_surfaces; i++, surf++) {
// light-emitting surfaces are of course lights
if ((surf->texinfo->flags & SURF_LIGHT) && surf->texinfo->value) {
VectorMA(surf->center, 1.0, surf->normal, origin);
radius = sqrt(surf->texinfo->light * sqrt(surf->area) * BSP_LIGHT_SURFACE_RADIUS_SCALE);
R_AddBspLight(bsp, origin, surf->texinfo->emissive, radius * s->brightness);
}
}
// parse the entity string for point lights
const char *ents = Cm_EntityString();
VectorClear(origin);
radius = BSP_LIGHT_POINT_DEFAULT_RADIUS * s->brightness;
VectorSet(color, 1.0, 1.0, 1.0);
char class_name[MAX_QPATH];
_Bool entity = false, light = false;
while (true) {
const char *c = ParseToken(&ents);
if (!strlen(c)) {
break;
}
if (*c == '{') {
entity = true;
}
if (!entity) { // skip any whitespace between ents
continue;
}
if (*c == '}') {
entity = false;
if (light) { // add it
R_AddBspLight(bsp, origin, color, radius * BSP_LIGHT_POINT_RADIUS_SCALE);
radius = BSP_LIGHT_POINT_DEFAULT_RADIUS;
VectorSet(color, 1.0, 1.0, 1.0);
light = false;
}
}
if (!g_strcmp0(c, "classname")) {
c = ParseToken(&ents);
g_strlcpy(class_name, c, sizeof(class_name));
if (!strncmp(c, "light", 5)) { // light, light_spot, etc..
light = true;
}
continue;
}
if (!g_strcmp0(c, "origin")) {
sscanf(ParseToken(&ents), "%f %f %f", &origin[0], &origin[1], &origin[2]);
continue;
}
if (!g_strcmp0(c, "light")) {
radius = atof(ParseToken(&ents)) * s->brightness;
continue;
}
if (!g_strcmp0(c, "_color")) {
sscanf(ParseToken(&ents), "%f %f %f", &color[0], &color[1], &color[2]);
ColorFilter(color, color, s->brightness, s->saturation, s->contrast);
continue;
}
}
// allocate the lights array and copy them in
bsp->num_bsp_lights = g_slist_length(r_bsp_light_state.lights);
bsp->bsp_lights = Mem_LinkMalloc(sizeof(r_bsp_light_t) * bsp->num_bsp_lights, bsp);
GSList *e = r_bsp_light_state.lights;
r_bsp_light_t *bl = bsp->bsp_lights;
while (e) {
*bl++ = *((r_bsp_light_t *) e->data);
e = e->next;
}
// reset state
g_slist_free_full(r_bsp_light_state.lights, Mem_Free);
r_bsp_light_state.lights = NULL;
Com_Debug(DEBUG_RENDERER, "Loaded %d bsp lights\n", bsp->num_bsp_lights);
}
