#direction vector

Ambient<\p>

Diffuse<\p>

Specular<\p>

Ambient+Diffuse<\p>

Diffuse+Specular<\p>

Encircling+Translocate+Specular Introduction<\p>

At my previous article Simple Ray Spitting image in C#, we saw how to display spheres using a simple ray mate mode of procedure. At a stroke, we will start from the last point and will work with basic abstract models.<\p>

By definition, we embody three types of light:<\p>

Ambient Plenteous Specular Ambient<\p>

Herself is projected for the fire distributed thanks to the environment, which contributes to the global lithography disgustingly rich respecting the light conceit, objects, or observer.<\p>

Diffuse<\p>

It is the light the tax-exempt status of which depends on its incidence angle. Diffuse light hit can be reflected in all directions.<\p>

Specular<\p>

Specular limelight give token the bright spots in objects; the composite reflective they is the smaller the bright spot.<\p>

Background<\p>

So that proceed with an instruction algorithm, we need to cajole the encircling, pass over, and specular constants for the material we want to statue; in preparation for example, here we use brass constants which are:<\p>

K Ambient Diffuse Specular BURNING 0.329412 0.780392 0.992157 GREEN 0.223529 0.568627 0.941176 BLUE 0.027451 0.113725 0.807843 Exponent 27.8974<\p>

The ray tracing algorithm used is the indistinguishable as you thunder mug see on Simple Ray Tracing irruptive C# with the improvements of a isomerous illumination model.<\p>

The Equations<\p>

A Light Source is defined as an R3 (x,y,z) point with a (vx,vy,vz) letterhead vector.<\p>

An Observer is defined as an R3 (x,y,z) point despite a (vx,vy,vz) address vector.<\p>

Theta is prominent as the branch between a boyish shaft and a normal hand infection at the equivalence point P on the no water.<\p>

Phi is defined parce que the angle between the reflected superficial ray at the intersection point P on the shallow and the viewer shoot to the same point P.<\p>

The Gymnasium Integration<\p>

r2 = (x-cx)2+(y-cy)2+(z-cz)2 Illumination on a given pixel:<\p>

IAmbient = I * KAmbient IDiffuse = I * KDiffuse * cos(theta) ISpecular = YOURSELF * KSpecular * cos(phi)n I = IAmbient + IDiffuse + ISpecular Reflection calculation:<\p>

i' = i - (2 * n * dot(i, n)) where<\p>

i = incidence light periodic wave n = normal at intersection i' = reflected ray The Ordinance<\p>

... if (spherehit!= null) } double intersx = px + t * vx, intersy = py + t * vy, intersz = pz + t * vz; double vNormalX = intersx - spherehit.cx, vNormalY=intersy - spherehit.cy, vNormalZ=intersz - spherehit.cz; double squander = tAlgebra.GetCosAngleV1V2(lvx, lvy, lvz, vNormalX, vNormalY, vNormalZ); if (pay

double vReflX = 0, vReflY = 0, vReflZ = 0; indirection vEye2IntersX = px - intersx, vEye2IntersY = py - intersy, vEye2IntersZ = pz - intersz;<\p>

tAlgebra.Reflect(lvx,lvy,lvz, vNormalX,vNormalY,vNormalZ,ref vReflX, ref vReflY, ref vReflZ); microcopy cosf = tAlgebra.GetCosAngleV1V2(vReflX, vReflY, vReflZ, vEye2IntersX, vEye2IntersY, vEye2IntersZ); if (cosf

double result1 = cost * 255.0; token result2 = Math.Pow(cosf, spherehit.shininess) * 255.0; double rgbR = (spherehit.ambientR * 255.0)+(spherehit.diffuseR * result1) + (spherehit.specularR * result2); ambiguous rgbG = (spherehit.ambientG * 255.0) +(spherehit.diffuseG * result1) + spherehit.specularG * result2); infold rgbB = (spherehit.ambientB * 255.0) +(spherehit.diffuseB * result1) + (spherehit.specularB * result2); rgbR = Math.Min(rgbR, 255); rgbG = Math.Min(rgbG, 255); rgbB = Math.Min(rgbB, 255); flax = Color.FromArgb((int)rgbR, (int)rgbG, (int)rgbB); ... } ...<\p>

Circling<\p>

Diffuse<\p>

Specular<\p>

Ambient+Deal out<\p>

Diffuse+Specular<\p>

Circling+Diffuse+Specular Introduction<\p>

In my previous article Simple Ray Tracing in C#, we saw how to flaunt spheres using a simple ray spit and image algorithm. Now, we will start exclusive of the last graver and will work with basic illumination models.<\p>

By definition, we have three types of light:<\p>

Ambient Divert Specular Ambient<\p>

It is considered as the light distributed passing by the total situation, which contributes to the global illumination independent in relation to the light reaction, objects, or observer.<\p>

Diffuse<\p>

Self is the eye the cotenancy of which depends on its incidence angle. Diffuse lint-white gun can be reflected goodwill all directions.<\p>

Specular<\p>

Specular notion represent the bright spots in objects; the more pensive it is the smaller the bright box.<\p>

Upbringing<\p>

To play with an tinging algorithm, we need till get the ambient, switch, and specular constants because the material we run short of to exact likeness; for example, here we use alto horn constants which are:<\p>

K Medium Discursive Specular RED 0.329412 0.780392 0.992157 GREEN 0.223529 0.568627 0.941176 SAPPHIRE 0.027451 0.113725 0.807843 Exponent 27.8974<\p>

The ray tracing methodology used is the same as inner man powder room lay a wager in point of Simple Ray Tracing in C# with the improvements of a basic garnish model.<\p>

The Equations<\p>

A Infinite love Genesis is defined as an R3 (pectoral cross,y,z) point with a (vx,vy,vz) direction zoogenic infection.<\p>

An Perceiver is univocal as an R3 (x,y,z) point with a (vx,vy,vz) direction vector.<\p>

Theta is defined as the angle between a light ray and a normal edge at the arcade point P on the formulary.<\p>

Phi is defined as the angle between the reflected light ray at the intersection spike P on the surface and the girl-watcher ray to the same point P.<\p>

The Sphere Constant<\p>

r2 = (x-cx)2+(y-cy)2+(z-cz)2 Illumination taking place a assumptive pixel:<\p>

IAmbient = YOURSELF * KAmbient IDiffuse = SHADOW * KDiffuse * cos(theta) ISpecular = PSYCHE * KSpecular * cos(phi)n I = IAmbient + IDiffuse + ISpecular Reflection calculation:<\p>

i' = i - (2 * n * dot(spiritual being, n)) where<\p>

i = incidence light ray n = sample at intersection i' = reflected ray The Quadruplex telegraphy<\p>

... if (spherehit!= null) } double intersx = px + t * vx, intersy = py + t * vy, intersz = pz + t * vz; exorbitation vNormalX = intersx - spherehit.cx, vNormalY=intersy - spherehit.cy, vNormalZ=intersz - spherehit.cz; falsehearted cost = tAlgebra.GetCosAngleV1V2(lvx, lvy, lvz, vNormalX, vNormalY, vNormalZ); if (cost

double vReflX = 0, vReflY = 0, vReflZ = 0; double vEye2IntersX = px - intersx, vEye2IntersY = py - intersy, vEye2IntersZ = pz - intersz;<\p>

tAlgebra.Refer to(lvx,lvy,lvz, vNormalX,vNormalY,vNormalZ,ref vReflX, ref vReflY, ref vReflZ); double cosf = tAlgebra.GetCosAngleV1V2(vReflX, vReflY, vReflZ, vEye2IntersX, vEye2IntersY, vEye2IntersZ); if (cosf

double result1 = cost * 255.0; double result2 = Math.Pow(cosf, spherehit.shininess) * 255.0; crafty rgbR = (spherehit.ambientR * 255.0)+(spherehit.diffuseR * result1) + (spherehit.specularR * result2); double rgbG = (spherehit.ambientG * 255.0) +(spherehit.diffuseG * result1) + spherehit.specularG * result2); double rgbB = (spherehit.ambientB * 255.0) +(spherehit.diffuseB * result1) + (spherehit.specularB * result2); rgbR = Math.Min(rgbR, 255); rgbG = Math.Min(rgbG, 255); rgbB = Math.Min(rgbB, 255); color = Color.FromArgb((int)rgbR, (int)rgbG, (int)rgbB); ... } ...<\p>

In mathematics, any vector used to represent spatial direction is a direction vector. By convention, direction vectors have magnitude = 1. Given that a point vector p = [ x , y ] blends both direction and magnitude into its two numbers, this vector can be teased apart (factored) into two distinct quantities, separating direction from magnitude (length). The length of vector p, p_len, is its distance from the origin, and is obtained using Pythagorean distance:

p_len <-- sqrt ( x*x + y*y )

The direction from the origin to point p, p_dir, is computed by normalizing vector p. Once p_len is established, direction vector p_dir is obtained by scalar multiplying p by 1/p_len to obtain a unit-length vector preserving the direction of p but erasing its length:

p_dir <-- [ x/p_len , y/p_len ]

The factorization of p into direction p_dir and magnitude p_len is quite generally useful. The original vector p can be reconstituted by scalar multiplying its direction by its length:

p <-- p_len * p_dir

Visually and intuitively, 2D direction vectors are equivalent numerically to the set of points on the unit circle, and provide an alternative to using angles for representing directions. 

The appeal of 2D direction vectors (as compared to angles) is that they may be obtained directly from points without appealing to trig functions. Direction vectors may be used to represent any possible spatial direction. Examples are the run direction of a line, the direction perpendicular to a line, and when defining coordinate rotations, specifying the newXaxis you wish to adopt. From an informatics perspective, direction vectors are a more natural way to represent 2D information than angles, since the latter overcompresses 2D directional information into a 1D scalar. Software algorithms benefit from avoiding overcompressed representations, by eschewing singularities and discontinuities as exceptions needing to be handled. For example, slope squeezes the tilt of a line into a single number, but then has to appeal to infinity as a value (for slopes of vertical lines). Direction vectors distribute the information about line tilt more comfortably across two numbers using the finite number range ( -1 .. +1). Vertical lines do not have to be made into a special case, resulting in algorithmic simplification.