void R3PointLight:: Draw(int i) const { // Draw light GLenum index = (GLenum) (GL_LIGHT2 + i); if (index > GL_LIGHT7) return; GLfloat buffer[4]; buffer[0] = Intensity() * Color().R(); buffer[1] = Intensity() * Color().G(); buffer[2] = Intensity() * Color().B(); buffer[3] = 1.0; glLightfv(index, GL_DIFFUSE, buffer); glLightfv(index, GL_SPECULAR, buffer); buffer[0] = Position().X(); buffer[1] = Position().Y(); buffer[2] = Position().Z(); buffer[3] = 1.0; glLightfv(index, GL_POSITION, buffer); buffer[0] = 180.0; glLightf(index, GL_SPOT_CUTOFF, buffer[0]); glEnable(index); buffer[0] = ConstantAttenuation(); buffer[1] = LinearAttenuation(); buffer[2] = QuadraticAttenuation(); glLightf(index, GL_CONSTANT_ATTENUATION, buffer[0]); glLightf(index, GL_LINEAR_ATTENUATION, buffer[1]); glLightf(index, GL_QUADRATIC_ATTENUATION, buffer[2]); }
void Scene::initialize() { Source* s1 = new Source(Point(SWIDTH / 2, SHEIGHT / 2, SDEPTH / 2), Intensity(5000), 10.0); Source* s2 = new Source(Point(SWIDTH * 0.5, -SHEIGHT * 1.1, -SDEPTH * 0.6), Intensity(10000, 20000, 60000), 50); Source* s3 = new Source(Point(-SWIDTH * 0.5, 0, -SDEPTH * 0.3), Intensity(20000, 4000, 2000), 50); sources.append(s1); //sources.append(s2); //sources.append(s3); camera = new Camera(Point(SWIDTH * 0.5, SHEIGHT * 0.5, -SDEPTH * 0.3 - CDEPTH)); camera->rotateZ(-0.1); }
RNScalar R3PointLight:: IntensityAtPoint(const R3Point& point) const { // Return intensity at point RNLength d = R3Distance(point, position); RNScalar denom = constant_attenuation; denom += d * linear_attenuation; denom += d * d * quadratic_attenuation; if (RNIsZero(denom)) return Intensity(); else return (Intensity() / denom); }
RNScalar R3PointLight:: RadiusOfInfluence(RNScalar intensity_threshhold) const { // Return distance beyond which intensity is below threshold // kq*d^2 + kl*d + (kc - 1/a) = 0 (use quadratic formula) if (RNIsZero(Intensity())) return 0.0; if (RNIsZero(intensity_threshhold)) return RN_INFINITY; RNScalar A = quadratic_attenuation; RNScalar B = linear_attenuation; RNScalar C = constant_attenuation - Intensity() / intensity_threshhold; RNScalar radius = (-B + sqrt(B*B - 4.0*A*C)) / (2.0*A); return radius; }
void ColorScreening(IplImage *src, IplImage *dst) { for (int i = 0; i < src->height; i++) { uchar* srcp = (uchar*)(src->imageData + i*src->widthStep); uchar* dstp = (uchar*)(dst->imageData + i*src->widthStep); for (int j = 0; j < src->width; j++) { unsigned int b = srcp[3*j]; unsigned int g = srcp[3*j+1]; unsigned int r = srcp[3*j+2]; unsigned int hue = Hue(r, g, b); float sat = Saturation(r, g, b); unsigned int ins = Intensity(r, g, b); //printf("src: %d %d %d\n", r, g, b); //printf("cal: %d %f %d\n", hue, sat, ins); if (((hue >= H_MIN1 && hue <= H_MAX1) || (hue >= H_MIN2 && hue <= H_MAX2)) && sat >= S_THRESHOLD && ins >= I_THRESHOLD){ dstp[3*j] = 0; dstp[3*j+1] = 0; dstp[3*j+2] = r; //printf("sto: %d %d %d\n", dstp[3*j], dstp[3*j+1], dstp[3*j+2]); } else { dstp[3*j] = 0; dstp[3*j+1] = 0; dstp[3*j+2] = 0; //printf("sto: %d %d %d\n", dstp[3*j], dstp[3*j+1], dstp[3*j+2]); } } } }
RNScalar R3DirectionalLight:: IntensityAtPoint(const R3Point& point) const { // Return intensity at point if (!IsActive()) return 0.0; return Intensity(); }
RNRgb R3DirectionalLight:: Reflection(const R3Brdf& brdf, const R3Point& eye, const R3Point& point, const R3Vector& normal) const { // Check if light is active if (!IsActive()) return RNblack_rgb; // Get material properties const RNRgb& Dc = brdf.Diffuse(); const RNRgb& Sc = brdf.Specular(); RNScalar s = brdf.Shininess(); // Get light properties RNScalar I = Intensity(); R3Vector L = -(Direction()); const RNRgb& Ic = Color(); // Compute geometric stuff RNScalar NL = normal.Dot(L); if (RNIsNegativeOrZero(NL)) return RNblack_rgb; R3Vector R = (2.0 * NL) * normal - L; R3Vector V = eye - point; V.Normalize(); RNScalar VR = V.Dot(R); // Compute diffuse reflection RNRgb rgb = (I * NL) * Dc * Ic; // Compute specular reflection if (RNIsPositive(VR)) rgb += (I * pow(VR,s)) * Sc * Ic; // Return total reflection return rgb; }
R3Sphere R3DirectionalLight:: SphereOfInfluence(RNScalar intensity_threshold) const { // Return sphere within which light intensity is above threshhold if (Intensity() > intensity_threshold) return R3infinite_sphere; else return R3null_sphere; }
RNScalar R3DirectionalLight:: RadiusOfInfluence(RNScalar intensity_threshold) const { // Return distance beyond which intensity is below threshold if (!IsActive()) return 0.0; if (Intensity() > intensity_threshold) return RN_INFINITY; else return 0.0; }
const void Experiment::printEx(int aufloesungsSchritte){ double alpha = -minima; ofstream myfile; myfile.open("Intensity.txt"); myfile << "# alpha | Intensity\n"; for(int i=0;i<2*aufloesungsSchritte;i++){ alpha += minima/aufloesungsSchritte; myfile << alpha << "\t" << Intensity(alpha,elec.Lambda()) << "\n"; } // end for myfile.close(); }
Material::Material (const Scene* const scene) : m_name("default") { float coeff[3] = { 1.0, 1.0, 1.0 }; m_scene = scene; m_Kss = 0; m_Ka = Intensity (coeff); m_diffuseTexture = -1; }
void R3DirectionalLight:: Draw(int i) const { // Draw light GLenum index = (GLenum) (GL_LIGHT0 + i); if (index > GL_LIGHT7) return; GLfloat buffer[4]; buffer[0] = Intensity() * Color().R(); buffer[1] = Intensity() * Color().G(); buffer[2] = Intensity() * Color().B(); buffer[3] = 1.0; glLightfv(index, GL_DIFFUSE, buffer); glLightfv(index, GL_SPECULAR, buffer); buffer[0] = -(Direction().X()); buffer[1] = -(Direction().Y()); buffer[2] = -(Direction().Z()); buffer[3] = 0.0; glLightfv(index, GL_POSITION, buffer); buffer[0] = 180.0; glLightf(index, GL_SPOT_CUTOFF, buffer[0]); glEnable(index); }
Material::Material ( const Scene* const scene, const string& name, float *const ambientCoefficients, float *const diffuseCoefficients, float *const specularCoefficients, float specularExponent, int tex) : m_name(name) { m_scene = scene; m_Kss = specularExponent; if (ambientCoefficients != NULL) { m_Ka = Intensity (ambientCoefficients); } if (diffuseCoefficients != NULL) { m_Kd = Intensity (diffuseCoefficients); } if (specularCoefficients != NULL) { m_Ks = Intensity (specularCoefficients); } m_Kss = specularExponent; m_diffuseTexture = tex; }
/* Initialise the Maxim driver(s) */ void HCMAX7219::Init(void) { byte DriverIndex; for (DriverIndex = 0; DriverIndex < NUMBEROFDRIVERS; DriverIndex++) { Write(MAX7219DECODE, 0,DriverIndex); Intensity(0x0F, DriverIndex); SevenSegDigits(7, DriverIndex); TestMode(TESTMODEOFF, DriverIndex); Shutdown(MAX7219ON, DriverIndex); Clear(); Refresh(); } }
RNRgb R3DirectionalLight:: DiffuseReflection(const R3Brdf& brdf, const R3Point& point, const R3Vector& normal) const { // Check if light is active if (!IsActive()) return RNblack_rgb; // Get material properties const RNRgb& Dc = brdf.Diffuse(); // Get light properties const RNRgb& Ic = Color(); RNScalar I = Intensity(); R3Vector L = -(Direction()); // Compute geometric stuff RNScalar NL = normal.Dot(L); if (RNIsNegativeOrZero(NL)) return RNblack_rgb; // Return diffuse component of reflection return (I * NL) * Dc * Ic; }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % N o r m a l i z e I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method NormalizeImage normalizes the pixel values to span the full % range of color values. This is a contrast enhancement technique. % % The format of the NormalizeImage method is: % % void NormalizeImage(Image *image) % % A description of each parameter follows: % % o image: The address of a structure of type Image; returned from % ReadImage. % % */ Export void NormalizeImage(Image *image) { #define NormalizeImageText " Normalizing image... " int *histogram, threshold_intensity, y; Quantum gray_value, *normalize_map; register int i, intensity, x; register PixelPacket *p, *q; unsigned int high, low; /* Allocate histogram and normalize map. */ assert(image != (Image *) NULL); histogram=(int *) AllocateMemory((MaxRGB+1)*sizeof(int)); normalize_map=(Quantum *) AllocateMemory((MaxRGB+1)*sizeof(Quantum)); if ((histogram == (int *) NULL) || (normalize_map == (Quantum *) NULL)) { MagickWarning(ResourceLimitWarning,"Unable to normalize image", "Memory allocation failed"); return; } /* Form histogram. */ for (i=0; i <= MaxRGB; i++) histogram[i]=0; for (y=0; y < (int) image->rows; y++) { p=GetPixelCache(image,0,y,image->columns,1); if (p == (PixelPacket *) NULL) break; for (x=0; x < (int) image->columns; x++) { gray_value=Intensity(*p); histogram[gray_value]++; p++; } } /* Find the histogram boundaries by locating the 1 percent levels. */ threshold_intensity=(image->columns*image->rows)/100; intensity=0; for (low=0; low < MaxRGB; low++) { intensity+=histogram[low]; if (intensity > threshold_intensity) break; } intensity=0; for (high=MaxRGB; high != 0; high--) { intensity+=histogram[high]; if (intensity > threshold_intensity) break; } if (low == high) { /* Unreasonable contrast; use zero threshold to determine boundaries. */ threshold_intensity=0; intensity=0; for (low=0; low < MaxRGB; low++) { intensity+=histogram[low]; if (intensity > threshold_intensity) break; } intensity=0; for (high=MaxRGB; high != 0; high--) { intensity+=histogram[high]; if (intensity > threshold_intensity) break; } if (low == high) return; /* zero span bound */ } /* Stretch the histogram to create the normalized image mapping. */ for (i=0; i <= MaxRGB; i++) if (i < (int) low) normalize_map[i]=0; else if (i > (int) high) normalize_map[i]=MaxRGB; else normalize_map[i]=(MaxRGB-1)*(i-low)/(high-low); /* Normalize the image. */ switch (image->class) { case DirectClass: default: { /* Normalize DirectClass image. */ for (y=0; y < (int) image->rows; y++) { q=GetPixelCache(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; for (x=0; x < (int) image->columns; x++) { q->red=normalize_map[q->red]; q->green=normalize_map[q->green]; q->blue=normalize_map[q->blue]; q++; } if (!SyncPixelCache(image)) break; if (QuantumTick(y,image->rows)) ProgressMonitor(NormalizeImageText,y,image->rows); } break; } case PseudoClass: { /* Normalize PseudoClass image. */ for (i=0; i < (int) image->colors; i++) { image->colormap[i].red=normalize_map[image->colormap[i].red]; image->colormap[i].green=normalize_map[image->colormap[i].green]; image->colormap[i].blue=normalize_map[image->colormap[i].blue]; } SyncImage(image); break; } } FreeMemory(normalize_map); FreeMemory(histogram); }
/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % E q u a l i z e I m a g e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Method EqualizeImage performs histogram equalization on the reference % image. % % The format of the EqualizeImage method is: % % void EqualizeImage(Image *image) % % A description of each parameter follows: % % o image: The address of a structure of type Image; returned from % ReadImage. % % */ Export void EqualizeImage(Image *image) { #define EqualizeImageText " Equalizing image... " int j, y; Quantum *equalize_map; register int i, x; register PixelPacket *p, *q; unsigned int high, *histogram, low, *map; /* Allocate and initialize histogram arrays. */ assert(image != (Image *) NULL); histogram=(unsigned int *) AllocateMemory((MaxRGB+1)*sizeof(unsigned int)); map=(unsigned int *) AllocateMemory((MaxRGB+1)*sizeof(unsigned int)); equalize_map=(Quantum *) AllocateMemory((MaxRGB+1)*sizeof(Quantum)); if ((histogram == (unsigned int *) NULL) || (map == (unsigned int *) NULL) || (equalize_map == (Quantum *) NULL)) { MagickWarning(ResourceLimitWarning,"Unable to equalize image", "Memory allocation failed"); return; } /* Form histogram. */ for (i=0; i <= MaxRGB; i++) histogram[i]=0; for (y=0; y < (int) image->rows; y++) { p=GetPixelCache(image,0,y,image->columns,1); if (p == (PixelPacket *) NULL) break; for (x=0; x < (int) image->columns; x++) { histogram[Intensity(*p)]++; p++; } } /* Integrate the histogram to get the equalization map. */ j=0; for (i=0; i <= MaxRGB; i++) { j+=histogram[i]; map[i]=j; } FreeMemory(histogram); if (map[MaxRGB] == 0) { FreeMemory(equalize_map); FreeMemory(map); return; } /* Equalize. */ low=map[0]; high=map[MaxRGB]; for (i=0; i <= MaxRGB; i++) equalize_map[i]=(Quantum) ((((double) (map[i]-low))*MaxRGB)/Max(high-low,1)); FreeMemory(map); /* Stretch the histogram. */ switch (image->class) { case DirectClass: default: { /* Equalize DirectClass packets. */ for (y=0; y < (int) image->rows; y++) { q=GetPixelCache(image,0,y,image->columns,1); if (q == (PixelPacket *) NULL) break; for (x=0; x < (int) image->columns; x++) { q->red=equalize_map[q->red]; q->green=equalize_map[q->green]; q->blue=equalize_map[q->blue]; q++; } if (!SyncPixelCache(image)) break; if (QuantumTick(y,image->rows)) ProgressMonitor(EqualizeImageText,y,image->rows); } break; } case PseudoClass: { /* Equalize PseudoClass packets. */ for (i=0; i < (int) image->colors; i++) { image->colormap[i].red=equalize_map[image->colormap[i].red]; image->colormap[i].green=equalize_map[image->colormap[i].green]; image->colormap[i].blue=equalize_map[image->colormap[i].blue]; } SyncImage(image); break; } } FreeMemory(equalize_map); }
void ON_Light::Dump( ON_TextLog& dump ) const { ON_BOOL32 bDumpDir = false; ON_BOOL32 bDumpLength = false; ON_BOOL32 bDumpWidth = false; const char* sStyle = "unknown"; switch(Style()) { //case ON::view_directional_light: // sStyle = "view_directional_light"; // bDumpDir = true; // break; //case ON::view_point_light: // sStyle = "view_point_light"; // break; //case ON::view_spot_light: // sStyle = "view_spot_light"; // bDumpDir = true; // break; case ON::camera_directional_light: sStyle = "camera_directional_light"; bDumpDir = true; break; case ON::camera_point_light: sStyle = "camera_point_light"; break; case ON::camera_spot_light: sStyle = "camera_spot_light"; bDumpDir = true; break; case ON::world_directional_light: sStyle = "world_directional_light"; bDumpDir = true; break; case ON::world_point_light: sStyle = "world_point_light"; break; case ON::world_spot_light: sStyle = "world_spot_light"; bDumpDir = true; break; case ON::world_linear_light: sStyle = "linear_light"; bDumpDir = true; bDumpLength = true; break; case ON::world_rectangular_light: sStyle = "rectangular_light"; bDumpDir = true; bDumpLength = true; bDumpWidth = true; break; case ON::ambient_light: sStyle = "ambient_light"; break; case ON::unknown_light_style: sStyle = "unknown"; break; default: sStyle = "unknown"; break; } dump.Print("index = %d style = %s\n",LightIndex(),sStyle); dump.Print("location = "); dump.Print(Location()); dump.Print("\n"); if ( bDumpDir ) dump.Print("direction = "); dump.Print(Direction()); dump.Print("\n"); if ( bDumpLength ) dump.Print("length = "); dump.Print(Length()); dump.Print("\n"); if ( bDumpWidth ) dump.Print("width = "); dump.Print(Width()); dump.Print("\n"); dump.Print("intensity = %g%%\n",Intensity()*100.0); dump.Print("ambient rgb = "); dump.PrintRGB(Ambient()); dump.Print("\n"); dump.Print("diffuse rgb = "); dump.PrintRGB(Diffuse()); dump.Print("\n"); dump.Print("specular rgb = "); dump.PrintRGB(Specular()); dump.Print("\n"); dump.Print("spot angle = %g degrees\n",SpotAngleDegrees()); }
int CLightManager::Add (CSegFace* faceP, tRgbaColorf *colorP, fix xBrightness, short nSegment, short nSide, short nObject, short nTexture, CFixVector *vPos, ubyte bAmbient) { CDynLight* pl; short h, i; float fBrightness = X2F (xBrightness); #if USE_OGL_LIGHTS GLint nMaxLights; #endif #if 0 if (xBrightness > I2X (1)) xBrightness = I2X (1); #endif if (fBrightness <= 0) return -1; #if DBG if ((nDbgSeg >= 0) && (nSegment == nDbgSeg)) nSegment = nSegment; if ((nDbgObj >= 0) && (nObject == nDbgObj)) nDbgObj = nDbgObj; if (colorP && ((colorP->red > 1) || (colorP->green > 1) || (colorP->blue > 1))) colorP = colorP; #endif if (gameStates.render.nLightingMethod && (nSegment >= 0) && (nSide >= 0)) { #if 1 fBrightness /= Intensity (colorP->red, colorP->green, colorP->blue); #else if (fBrightness < 1) fBrightness = (float) sqrt (fBrightness); else fBrightness *= fBrightness; #endif } if (colorP) colorP->alpha = 1.0f; if (0 <= (h = Update (colorP, fBrightness, nSegment, nSide, nObject))) return h; if (!colorP) return -1; if ((colorP->red == 0.0f) && (colorP->green == 0.0f) && (colorP->blue == 0.0f)) { if (gameStates.app.bD2XLevel && gameStates.render.bColored) return -1; colorP->red = colorP->green = colorP->blue = 1.0f; } if (m_data.nLights [0] >= MAX_OGL_LIGHTS) { gameStates.render.bHaveDynLights = 0; return -1; //too many lights } i = m_data.nLights [0]; //LastEnabledDynLight () + 1; pl = m_data.lights + i; pl->info.faceP = faceP; pl->info.nSegment = nSegment; pl->info.nSide = nSide; pl->info.nObject = nObject; pl->info.nPlayer = -1; pl->info.bState = 1; pl->info.bSpot = 0; pl->info.fBoost = 0; pl->info.bPowerup = 0; pl->info.bAmbient = bAmbient; //0: static light //2: object/lightning //3: headlight if (nObject >= 0) { CObject *objP = OBJECTS + nObject; //HUDMessage (0, "Adding object light %d, type %d", m_data.nLights [0], objP->info.nType); pl->info.nType = 2; if (objP->info.nType == OBJ_POWERUP) { int id = objP->info.nId; if ((id == POW_EXTRA_LIFE) || (id == POW_ENERGY) || (id == POW_SHIELD_BOOST) || (id == POW_HOARD_ORB) || (id == POW_MONSTERBALL) || (id == POW_INVUL)) pl->info.bPowerup = 1; else pl->info.bPowerup = 2; } pl->info.vPos = objP->info.position.vPos; pl->info.fRad = 0; //X2F (OBJECTS [nObject].size) / 2; if (fBrightness > 1) { if ((objP->info.nType == OBJ_FIREBALL) || (objP->info.nType == OBJ_EXPLOSION)) { pl->info.fBoost = 1; pl->info.fRad = fBrightness; } else if ((objP->info.nType == OBJ_WEAPON) && (objP->info.nId == FLARE_ID)) { pl->info.fBoost = 1; pl->info.fRad = 2 * fBrightness; } } m_data.owners [nObject] = m_data.nLights [0]; } else if (nSegment >= 0) { #if 0 CFixVector vOffs; CSide *sideP = SEGMENTS [nSegment].m_sides + nSide; #endif if (nSide < 0) { pl->info.nType = 2; pl->info.bVariable = 0; pl->info.fRad = 0; if (vPos) pl->info.vPos = *vPos; else pl->info.vPos = SEGMENTS [nSegment].Center (); } else { #if DBG if ((nSegment == nDbgSeg) && ((nDbgSide < 0) || (nSide == nDbgSide))) nDbgSeg = nDbgSeg; #endif pl->info.nType = 0; pl->info.fRad = faceP ? faceP->fRads [1] / 2.0f : 0; //RegisterLight (NULL, nSegment, nSide); pl->info.bVariable = IsDestructible (nTexture) || IsFlickering (nSegment, nSide) || IsTriggered (nSegment, nSide) || SEGMENTS [nSegment].Side (nSide)->IsVolatile (); m_data.nVariable += pl->info.bVariable; CSide* sideP = SEGMENTS [nSegment].m_sides + nSide; pl->info.vPos = sideP->Center (); CFixVector vOffs = CFixVector::Avg (sideP->m_normals [0], sideP->m_normals [1]); pl->info.vDirf.Assign (vOffs); CFloatVector::Normalize (pl->info.vDirf); #if 0 if (gameStates.render.bPerPixelLighting) { vOffs *= I2X (1) / 64; pl->info.vPos += vOffs; } #endif } } else { pl->info.nType = 3; pl->info.bVariable = 0; } #if 0 PrintLog ("adding light %d,%d\n", m_data.nLights [0], pl - m_data.lights [0]); #endif pl->info.bOn = 1; pl->bTransform = 1; SetColor (m_data.nLights [0], colorP->red, colorP->green, colorP->blue, fBrightness); return m_data.nLights [0]++; }
RNScalar R3DirectionalLight:: IntensityAtPoint(const R3Point& ) const { // Return intensity at point return Intensity(); }