Transformation In 3D graphics,
transformation is often used to operate on vertices and vectors. It is also
used to convert them in one space to another. Transformation is performed via
multiplication with a matrix. There are typically three types of primitive
transformation that can be performed on vertices: translation (where it lies
in space relative to the origin), rotation (its direction in relation to the
x, y, z frame), and scaling (its distance from origin). In addition to those,
projection transformation is used to go from view space to projection space.
The D3DX library contains APIs that can conveniently construct a matrix for
many purposes such as translation, rotation, scaling, world-to-view
transformation, view-to-projection transformation, etc. An application can
then use these matrices to transform vertices in its scene. A basic
understanding of matrix transformations is required. We will briefly look at
some examples below. Translation Translation
refers to moving or displacing for a certain distance in space. In 3D, the
matrix used for translation has the form 1 0
0 0 0 1
0 0 0 0
1 0 a b
c 1 where (a, b, c)
is the vector that defines the direction and distance to move. For example,
to move a vertex -5 unit along the X axis (negative X direction), we can
multiply it with this matrix: 1 0
0 0 0 1
0 0 0 0
1 0 -5 0
0 1 If we apply this
to a cube object centered at origin, the result is that the box is moved 5
units towards the negative X axis, as figure 5 shows, after translation is
applied. The effect of translation In 3D, a space is
typically defined by an origin and three unique axes from the origin: X, Y
and Z. There are several spaces commonly used in computer graphics: object
space, world space, view space, projection space, and screen space. Rotation Rotation refers
to rotating vertices about an axis going through the origin. Three such axes
are the X, Y, and Z axes in the space. An example in 2D would be rotating the
vector [1 0] 90 degrees counter-clockwise. The result from the rotation is
the vector [0 1]. The matrix used for rotating ? degrees clockwise about the
Y axis looks like this: cos?
0 -sin? 0
0 1 0
0 sin?
0 cos? 0
0 0 0
1 Figure shows the
effect of rotating a cube centered at origin for 45 degrees about the Y axis. Scaling Scaling refers to
enlarging or shrinking the size of vector components along axis directions.
For example, a vector can be scaled up along all directions or scaled down
along the X axis only. To scale, we usually apply the scaling matrix below: p 0
0 0 0 q
0 0 0 0 r 0 0 0
0 1 Where p, q, and r
are the scaling factor along the X, Y, and Z direction, respectively. The
figure below shows the effect of scaling by 2 along the X axis and scaling by
0.5 along the Y axis.
Parallel projection Parallel projections have lines of projection that are parallel both in reality and in the projection plane. Parallel projection corresponds to a perspective projection with an infinite focal length (the distance from the image plane to the projection point), or "zoom". Within parallel projection there is an ancillary category known
as "pictorials". Pictorials show an image of an object as viewed
from a skew direction in order to reveal all three directions (axes) of space
in one picture. Because pictorial projections innately contain this
distortion, in the rote, drawing instrument for pictorials, some liberties
may be taken for economy of effort and best effect. Axonometric projection
Axonometric projection is a type of orthographic projection
where the plane or axis of the object depicted is not parallel to the projection plane, such that multiple sides of an
object are visible in the same image. It
is further subdivided into three groups: isometric,dimetric and trimetric projection,
depending on the exact angle at which the view deviates from the orthogonal. A typical characteristic of
axonometric pictorials is that one axis of space is usually displayed as
vertical. Comparison of several types of graphical projection. Isometric
projection
In isometric pictorials (for protocols see isometric projection), the most
common form of axonometric projection, the
direction of viewing is such that the three axes of space appear equally
foreshortened. There are two commonly used standards for creating scaled
isometric drawings. An accurate drawing of a three-dimensional object
projected isometrically would have its axis-parallel edges foreshortened by a
factor of Dimetric projection
In dimetric pictorials (for protocols see dimetric projection), the direction
of viewing is such that two of the three axes of space appear equally
foreshortened, of which the attendant scale and angles of presentation are
determined according to the angle of viewing; the scale of the third
direction (vertical) is determined separately. Approximations are common in
dimetric drawings. Trimetric
projection
In trimetric pictorials (for protocols see trimetric projection), the direction
of viewing is such that all of the three axes of space appear unequally
foreshortened. The scale along each of the three axes and the angles among
them are determined separately as dictated by the angle of viewing.
Approximations in trimetric drawings are common, and trimetric perspective is seldom
used. Oblique projection
In oblique
projections the parallel
projection rays are not perpendicular to the viewing plane as with
orthographic projection, but strike the projection plane at an angle other
than ninety degrees. In both
orthographic and oblique projection, parallel lines in space appear parallel
on the projected image. Because of its simplicity, oblique projection is used
exclusively for pictorial purposes rather than for formal, working drawings.
In an oblique pictorial drawing,
the displayed angles among the axes as well as the foreshortening factors
(scale) are arbitrary. The distortion created thereby is usually attenuated
by aligning one plane of the imaged object to be parallel with the plane of
projection thereby creating a true shape, full-size image of the chosen
plane. Special types of oblique projections are cavalier projection and cabinet projection. REFERENCE {https://en.wikipedia.org/wiki/Parallel_projection} Perspective Projection Perspective (from Latin: perspicere to see through) in the graphic
arts is an approximate representation, on a flat surface
(such as paper), of an image as it is seen by the eye. The two most
characteristic features of perspective are that objects are smaller as their
distance from the observer increases; and that they are foreshortened,
meaning that an object's dimensions along the line of sight are shorter than
its dimensions across the line of sight. Linear perspective
always works by representing the light that passes from a scene through an
imaginary rectangle (the painting), to the viewer's eye. It is similar to a
viewer looking through a window and painting what is seen directly onto the
windowpane. If viewed from the same spot as the windowpane was painted, the
painted image would be identical to what was seen through the unpainted
window. Each painted object in the scene is a flat, scaled down version of
the object on the other side of the window.[1] Because each
portion of the painted object lies on the straight line from the viewer's eye
to the equivalent portion of the real object it represents, the viewer cannot
perceive (sans depth
perception) any difference between the painted scene on the windowpane and
the view of the real scene. All perspective drawings assume the viewer is a
certain distance away from the drawing. Objects are scaled relative to that
viewer. An object is often not scaled evenly: a circle often appears as an
ellipse and a square can appear as a trapezoid. This distortion is referred
to as foreshortening. Perspective drawings
have a horizon line, which is often implied. This line, directly opposite the
viewer's eye, represents objects infinitely far away. They have shrunk, in
the distance, to the infinitesimal thickness of a line. It is analogous to
(and named after) the Earth's horizon. Any perspective
representation of a scene that includes parallel lines has one or more vanishing points in
a perspective drawing. A one-point perspective drawing means that the drawing
has a single vanishing point, usually (though not necessarily) directly
opposite the viewer's eye and usually (though not necessarily) on the horizon
line. All lines parallel with the viewer's line of sight recede to the
horizon towards this vanishing point. This is the standard "receding
railroad tracks" phenomenon. A two-point drawing would have lines
parallel to two different angles. Any number of vanishing points are possible
in a drawing, one for each set of parallel lines that are at an angle relative
to the plane of the drawing. Perspectives
consisting of many parallel lines are observed most often when drawing
architecture (architecture frequently uses lines parallel to the x, y, and z axes). Because it is rare to have a scene
consisting solely of lines parallel to the three Cartesian axes (x, y, and
z), it is rare to see perspectives in practice with only one, two, or three
vanishing points; even a simple house frequently has a peaked roof which
results in a minimum of six sets of parallel lines, in turn corresponding to
up to six vanishing points. In contrast, natural
scenes often do not have any sets of parallel lines and thus no vanishing
points.
Hidden surface
determination In 3D
computer graphics, hidden surface determination (also
known as hidden surface removal (HSR), occlusion culling (OC) or visible surface determination (VSD)) is the process used to determine which surfaces and parts
of surfaces are not visible from a certain viewpoint. A hidden surface
determination algorithm is a solution to the visibility problem, which was one of the first major problems in the
field of 3D computer graphics. The process of hidden surface determination is
sometimes called hiding, and such an algorithm is
sometimes called a hider. The analogue for line
rendering is hidden line
removal. Hidden surface determination is
necessary to render an image correctly, so that one cannot look through walls
in virtual reality. Hidden
surface removal algorithms Considering the rendering pipeline, the projection, the clipping, and
the rasterization steps
are handled differently by the following algorithms: ·
Z-buffering Duringrasterization the depth/Z value
of each pixel (or sample in the case of anti-aliasing, but
without loss of generality the term pixel is used) is checked against an
existing depth value. If the current pixel is behind the pixel in the
Z-buffer, the pixel is rejected, otherwise it is shaded and its depth value
replaces the one in the Z-buffer. Z-buffering supports dynamic scenes easily,
and is currently implemented efficiently in graphics hardware. This is the
current standard. The cost of using Z-buffering is that it uses up to 4 bytes
per pixel, and that the rasterization algorithm needs to check each
rasterized sample against the z-buffer. The z-buffer can also suffer from
artifacts due to precision errors (also known as z-fighting), although this is far less common
now that commodity hardware supports 24-bit and higher precision buffers. ·
Coverage buffers (C-Buffer)
and Surface buffer (S-Buffer):
faster than z-buffers and commonly used in games in the Quake I era. Instead of storing the Z value
per pixel, they store list of already displayed segments per line of the
screen. New polygons are then cut against already displayed segments that would
hide them. An S-Buffer can display unsorted polygons, while a C-Buffer
requires polygons to be displayed from the nearest to the furthest. Because
the C-buffer technique does not require a pixel to be drawn more than once,
the process is slightly faster. This was commonly used with binary space
partitioning (BSP) trees, which would provide
sorting for the polygons. ·
Sorted Active Edge List: Used
in Quake 1, this was storing a list of the edges of already displayed
polygons (see scanline rendering). Polygons are displayed from the
nearest to the furthest. New polygons are clipped against already displayed
polygons' edges, creating new polygons to display then storing the additional
edges. It's much harder to implement than S/C/Z buffers, but it scales much
better with increases in resolution. ·
Painter's
algorithm sorts polygons by their barycenter and draws them back to front. This
produces few artifacts when applied to scenes with polygons of similar size
forming smooth meshes and back-face culling turned on. The cost here is the
sorting step and the fact that visual artifacts can occur. ·
Binary space
partitioning (BSP) divides a scene along planes
corresponding to polygon boundaries. The subdivision is constructed in such a
way as to provide an unambiguous depth ordering from any point in the scene
when the BSP tree is traversed. The disadvantage here is that the BSP tree is
created with an expensive pre-process. This means that it is less suitable
for scenes consisting of dynamic geometry. The advantage is that the data is
pre-sorted and error free, ready for the previously mentioned algorithms.
Note that the BSP is not a solution to HSR, only an aid. ·
Ray tracing attempts to model the path of light
rays to a viewpoint by tracing rays from the viewpoint into the scene.
Although not a hidden surface removal algorithm as such, it implicitly solves
the hidden surface removal problem by finding the nearest surface along each
view-ray. Effectively this is equivalent to sorting all the geometry on a per
pixel basis. ·
The Warnock algorithm divides the screen into smaller areas
and sorts triangles within these. If there is ambiguity (i.e., polygons
overlap in depth extent within these areas), then further subdivision occurs.
At the limit, subdivision may occur down to the pixel level. REFERENCE {https://en.wikipedia.org/wiki/Hidden_surface_determination
}
Painter’s
Algorithm The painter's algorithm, also known as a priority fill, is one of the simplest solutions to the visibility problem in 3D computer graphics. When projecting a 3D scene onto a 2D plane, it is necessary at some point to decide which polygons are visible, and which are hidden. The name "painter's algorithm" refers to the technique employed by many painters of painting distant parts of a scene before parts which are nearer thereby covering some areas of distant parts. The painter's algorithm sorts all the polygons in a scene by their depth and then paints them in this order, farthest to closest. It will paint over the parts that are normally not visible — thus solving the visibility problem — at the cost of having painted invisible areas of distant objects. The ordering used by the algorithm is called a 'depth order', and does not have to respect the numerical distances to the parts of the scene: the essential property of this ordering is, rather, that if one object obscures part of another then the first object is painted after the object that it obscures. Thus, a valid ordering can be described as a topological orderingof a directed acyclic graph representing occlusions between objects. The algorithm can fail in
some cases, including cyclic overlap or piercing polygons. In the case of
cyclic overlap, as shown in the figure to the right, Polygons A, B, and C
overlap each other in such a way that it is impossible to determine which
polygon is above the others. In this case, the offending polygons must be cut
to allow sorting. Newell's algorithm, proposed in 1972, provides a method for
cutting such polygons. Numerous methods have also been proposed in the field
of computational geometry. The case of piercing
polygons arises when one polygon intersects another. As with cyclic overlap,
this problem may be resolved by cutting the offending polygons. In basic implementations,
the painter's algorithm can be inefficient. It forces the system to render each
point on every polygon in the visible set, even if that polygon is occluded
in the finished scene. This means that, for detailed scenes, the painter's
algorithm can overly tax the computer hardware. A reverse painter's algorithm is
sometimes used, in which objects nearest to the viewer are painted first —
with the rule that paint must never be applied to parts of the image that are
already painted (unless they are partially transparent). In a computer
graphic system, this can be very efficient, since it is not necessary to
calculate the colors (using lighting, texturing and such) for parts of the
more distant scene that are hidden by nearby objects. However, the reverse
algorithm suffers from many of the same problems as the standard version. These and other flaws with
the algorithm led to the development of Z-buffer techniques,
which can be viewed as a development of the painter's algorithm, by resolving
depth conflicts on a pixel-by-pixel basis, reducing the need for a
depth-based rendering order. Even in such systems, a variant of the painter's
algorithm is sometimes employed. As Z-buffer implementations generally rely
on fixed-precision depth-buffer registers implemented in hardware, there is
scope for visibility problems due to rounding error. These are overlaps or
gaps at joins between polygons. To avoid this, some graphics engine
implementations "overrender" drawing the affected edges of both
polygons in the order given by painter's algorithm. This means that some
pixels are actually drawn twice (as in the full painter's algorithm) but this
happens on only small parts of the image and has a negligible performance
effect. REFERENCE {https://en.wikipedia.org/wiki/Painter%27s_algorithm
}
In computer graphics, z-buffering, also known as depth buffering, is the management of image depth coordinates in 3D graphics,
usually done in hardware, sometimes in software. It is one solution to the visibility problem, which is the problem of deciding which
elements of a rendered scene are visible, and which are hidden. The painter's algorithm is
another common solution which, though less efficient, can also handle
non-opaque scene elements. When an object is rendered,
the depth of a generated pixel (z
coordinate) is stored in a buffer (the z-buffer or depth buffer). This buffer is usually arranged as a two-dimensional
array (x-y) with one element for each screen pixel. If another object of the
scene must be rendered in the same pixel, the method compares the two depths
and overrides the current pixel if the object is closer to the observer. The
chosen depth is then saved to the z-buffer, replacing the old one. In the
end, the z-buffer will allow the method to correctly reproduce the usual
depth perception: a close object hides a farther one. This is called z-culling. The granularity of a
z-buffer has a great influence on the scene quality: a 16-bit z-buffer
can result in artifacts (called
"z-fighting") when two objects are very close to
each other. A 24-bit or 32-bit z-buffer
behaves much better, although the problem cannot be entirely eliminated
without additional algorithms. An 8-bit z-buffer
is almost never used since it has too little precision. Z-culling In rendering,
z-culling is early pixel elimination based on depth, a method that provides
an increase in performance when rendering of hidden surfaces is costly. It is
a direct consequence of z-buffering, where the depth of each pixel candidate
is compared to the depth of existing geometry behind which it might be
hidden. When using a z-buffer, a
pixel can be culled (discarded) as soon as its depth is known, which makes it
possible to skip the entire process of lighting and texturing a pixel
that would not be visible anyway.
Also, time-consuming pixel shaders will
generally not be executed for the culled pixels. This makes z-culling a good
optimization candidate in situations where fillrate,
lighting, texturing or pixel shaders are the main bottlenecks. While z-buffering allows the
geometry to be unsorted, sorting polygons by
increasing depth (thus using a reverse painter's algorithm) allows each screen pixel to be rendered
fewer times. This can increase performance in fillrate-limited scenes with
large amounts of overdraw, but if not combined with z-buffering it suffers
from severe problems such as: ·
polygons might occlude one
another in a cycle (e.g. : triangle A occludes B, B occludes C, C
occludes A), and ·
there is no canonical
"closest" point on a triangle (e.g.: no matter whether one sorts
triangles by their centroid or closest point or furthest point,
one can always find two triangles A and B such that A is "closer"
but in reality B should be drawn first). As such, a reverse painter's
algorithm cannot be used as an alternative to Z-culling (without strenuous
re-engineering), except as an optimization to Z-culling. For example, an
optimization might be to keep polygons sorted according to x/y-location and
z-depth to provide bounds, in an effort to quickly determine if two polygons
might possibly have an occlusion interaction. REFERENCE {https://en.wikipedia.org/wiki/Z-buffering }
Bézier curve A Bézier curve is a parametric curve frequently used in computer graphics and related fields. Generalizations of Bézier curves to higher dimensions are called Bézier surfaces, of which the Bézier triangle is a special case. In vector graphics, Bézier curves are used to model smooth curves that can be scaled indefinitely. "Paths", as they are commonly referred to in image manipulation program are combinations of linked Bézier curves. Paths are not bound by the limits ofrasterized images and are intuitive to modify. Bézier curves are also used in the time domain, particularly in animation and user interface[note 2] design. For example, a Bézier curve can be used to specify the velocity over time of an object such as an icon moving from A to B, rather than simply moving at a fixed number of pixels per step. When animators or interface designers talk about the "physics" or "feel" of an operation, they may be referring to the particular Bézier curve used to control the velocity over time of the move in question. This also applies to robotics where the motion of a welding arm, for example, should be smooth to avoid unnecessary wear. The mathematical basis for Bézier curves — the Bernstein polynomial — has been known since 1912, but its applicability to graphics was understood half a century later. Bézier curves were widely publicized in 1962 by the French engineer Pierre Bézier, who used them to design automobile bodies at Renault. The study of these curves was however first developed in 1959 by mathematician Paul de Casteljau using de Casteljau's algorithm, a numerically stable method to evaluate Bézier curves at Citroën, another French automaker. B-spline In the mathematical subfield
of numerical analysis, a B-spline, or basis spline, is a spline function
that has minimal support with
respect to a given degree, smoothness, and domain partition.
Any spline function of given degree can be expressed as a linear combination of
B-splines of that degree. Cardinal B-splines have knots that are equidistant
from each other. B-splines can be used forcurve-fitting and numerical differentiation of
experimental data. In the computer-aided design and computer graphics, spline functions are constructed as
linear combinations of B-splines with a set of control points. B-splines were investigated as early as the nineteenth century by Nikolai Lobachevsky. The term "B-spline" was coined by Isaac Jacob Schoenberg and is short for basis spline. A spline function is a piecewise polynomial function of degree <k in a variable x. The places where the pieces meet are known as knots. The number of internal knots must be equal to, or greater than k-1. Thus the spline function has limited support. The key property of spline functions is that they are continuous at the knots. Some derivatives of the spline function may also be continuous, depending on whether the knots are distinct or not. A fundamental theorem states that every spline function of a given degree, smoothness, and domain partition, can be uniquely represented as a linear combination of B-splines of that same degree and smoothness, and over that same partition. REFERENCE {https://en.wikipedia.org/wiki/B-spline }
Basic Illumination Model From Physics we can
derive models, called "illumination models", of how light reflects
from surfaces and produces what we perceive as color. In general, light
leaves some light source, e.g. a lamp or the sun, is reflected from many
surfaces and then finally reflected to our eyes, or through an image plane of
a camera. The contribution from the light that goes directly from
the light source and is reflected from the surface is called a "local
illumination model". So, for a local illumination model, the shading of
any surface is independent from the shading of all other surfaces. A "global illumination model" adds to the local
model the light that is reflected from other surfaces to the current surface.
A global illumination model is more comprehensive, more physically correct,
and produces more realistic images. It is also more computationally
expensive. We will first look at some basic properties of light and color,
the physics of light-surface interactions, local illumination models, and
global illumination models. Scan-line rendering methods use only local
illumination models, although they may use tricks to simulate global
illumination. Many current graphics images and commercial systems are in this
category, but many systems are becoming global illumination based. REFERENCE {https://www.siggraph.org/education/materials/HyperGraph/illumin/illum1.htm
} Phong Shading Phong shading refers to an interpolation technique
for surface shading in 3D computer
graphics. It is also called Phong interpolationor normal-vector
interpolation shading. Specifically,
it interpolates surface
normals across rasterized polygons
and computes pixel colors based on the interpolated normals and a reflection
model. Phong shading may also refer to the specific
combination of Phong interpolation and the Phong reflection
model. Gouraud shading Gouraud shading, named after Henri Gouraud,
is an interpolation method
used in computer graphics to
produce continuous shadingof
surfaces represented by polygon meshes. In practice, Gouraud shading is most
often used to achieve continuous lighting on triangle surfaces by computing
the lighting at the corners of each triangle and linearly
interpolating the resulting colours for each pixelcovered
by the triangle. Gouraud first published the technique in 1971. REFERENCE {https://en.wikipedia.org/wiki/Gouraud_shading}
Ray Tracing In computer graphics, ray tracing is a
technique for generating an image by
tracing the path of light through pixels in
an image
planeand simulating the effects of its encounters with virtual
objects. The technique is capable of producing a very high degree of visual
realism, usually higher than that of typical scanline rendering methods,
but at a greater computational
cost. This makes ray tracing best suited for applications where
the image can be rendered slowly ahead of time, such as in still images and
film and televisionvisual
effects, and more poorly suited for real-time applications like video
games where speed is critical. Ray tracing is capable of
simulating a wide variety of optical effects, such as reflection and refraction, scattering,
and dispersion phenomena
(such aschromatic
aberration). Optical ray tracing describes a method for producing visual images constructed in 3D computer graphics environments, with more photorealism than either ray casting or scanline rendering techniques. It works by tracing a path from an imaginary eye through each pixel in a virtual screen, and calculating the color of the object visible through it. Scenes in ray tracing are described mathematically by a programmer or by a visual artist (typically using intermediary tools). Scenes may also incorporate data from images and models captured by means such as digital photography. Typically, each ray must be tested for intersection with some subset of all the objects in the scene. Once the nearest object has been identified, the algorithm will estimate the incoming light at the point of intersection, examine the material properties of the object, and combine this information to calculate the final color of the pixel. Certain illumination algorithms and reflective or translucent materials may require more rays to be re-cast into the scene. It may at first seem counterintuitive or "backwards" to send rays away from the camera, rather than into it (as actual light does in reality), but doing so is many orders of magnitude more efficient. Since the overwhelming majority of light rays from a given light source do not make it directly into the viewer's eye, a "forward" simulation could potentially waste a tremendous amount of computation on light paths that are never recorded. Therefore, the shortcut taken in raytracing is to presuppose that a given ray intersects the view frame. After either a maximum number of reflections or a ray traveling a certain distance without intersection, the ray ceases to travel and the pixel's value is updated. REFERENCE {https://en.wikipedia.org/wiki/Ray_tracing_(graphics)} Color models A color model is an
abstract mathematical model describing the way colors can
be represented as tuples of
numbers, typically as three or four values or color components. When this
model is associated with a precise description of how the components are to
be interpreted (viewing conditions, etc.), the resulting set of colors is
called color
space. This section describes ways in which humancolor
vision can be modeled. RGBColor models The RGB color model is an additive color model in which red, green, and blue light are added together in various ways to reproduce a broad array of colors. The name of the model comes from the initials of the three additive primary colors, red, green, and blue. The main purpose of the RGB color model is for the sensing, representation, and display of images in electronic systems, such as televisions and computers, though it has also been used in conventional photography. Before the electronic age, the RGB color model already had a solid theory behind it, based in human perception of colors. RGB is a device-dependent color model: different devices detect or reproduce a given RGB value differently, since the color elements (such as phosphors or dyes) and their response to the individual R, G, and B levels vary from manufacturer to manufacturer, or even in the same device over time. Thus an RGB value does not define the same color across devices without some kind of color management. Typical RGB input devices are color TV and video cameras, image scanners, video games, and digital cameras. Typical RGB output devices are TV sets of various technologies (CRT, LCD, plasma, etc.), computer and mobile phone displays, video projectors, multicolorLED displays, and large screens such as JumboTron. Color printers, on the other hand, are not RGB devices, but subtractive colordevices (typically CMYK color model). This article discusses concepts common to all the different color spaces that use the RGB color model, which are used in one implementation or another in color image-producing technology. YIQColor models YIQ is the color space used by the NTSC color TV system, employed mainly in North and Central America, and Japan. I stands for in-phase, while Q stands for quadrature, referring to the components used in quadrature amplitude modulation. Some forms of NTSC now use the YUV color space, which is also used by other systems such as PAL. The Y component represents the luma information, and is the only component used by black-and-white television receivers. I and Q represent the chrominance information. In YUV, the U and V components can be thought of as X and Y coordinates within the color space. I and Q can be thought of as a second pair of axes on the same graph, rotated 33°; therefore IQ and UV represent different coordinate systems on the same plane. The YIQ system is intended to take advantage of human color-response characteristics. The eye is more sensitive to changes in the orange-blue (I) range than in the purple-green range (Q) — therefore less bandwidth is required for Q than for I. Broadcast NTSC limits I to 1.3 MHz and Q to 0.4 MHz. I and Q are frequency interleaved into the 4 MHz Y signal, which keeps the bandwidth of the overall signal down to 4.2 MHz. In YUV systems, since U and V both contain information in the orange-blue range, both components must be given the same amount of bandwidth as I to achieve similar color fidelity. Very few television sets perform true I and Q decoding, due to the high costs of such an implementation. Compared to the cheaper R-Y and B-Y decoding which requires only one filter, I and Q each requires a different filter to satisfy the bandwidth differences between I and Q. These bandwidth differences also requires that the 'I' filter include a time delay to match the longer delay of the 'Q' filter. The Rockwell Modular Digital Radio (MDR) was one I and Q decoding set, which in 1997 could operate in frame-at-a-time mode with a PC or in realtime with the Fast IQ Processor (FIQP). Some RCA "Colortrak" home TV receivers made circa 1985 not only used I/Q decoding, but also advertised its benefits along with its comb filtering benefits as full "100 percent processing" to deliver more of the original color picture content. Earlier, more than one brand of color TV (RCA, Arvin) used I/Q decoding in the 1954 or 1955 model year on models utilizing screens about 13 inches (measured diagonally). The original Advent projection television used I/Q decoding. Around 1990, at least one manufacturer (Ikegami) of professional studio picture monitors advertised I/Q decoding. CMYK color model The CMYK color model (process color, four color) is a subtractive color model, used in color printing, and is also used to describe the printing process itself. CMYK refers to the four inks used in some color printing: cyan, magenta, yellow, and key (black). Though it varies by print house, press operator, press manufacturer, and press run, ink is typically applied in the order of the abbreviation. The "K" in CMYK stands for key because in four-color printing, cyan, magenta, and yellow printing plates are carefully keyed, or aligned, with the key of the black key plate. Some sources suggest that the "K" in CMYK comes from the last letter in "black" and was chosen because B already means blue. However, this explanation, although useful as a mnemonic, is incorrect. K is used as "Key", which was possibly chosen because black is often used as outline. The CMYK model works by partially or entirely masking colors on a lighter, usually white, background. The ink reduces the light that would otherwise be reflected. Such a model is called subtractive because inks "subtract" brightness from white. In additive color models such as RGB, white is the "additive" combination of all primary colored lights, while black is the absence of light. In the CMYK model, it is the opposite: white is the natural color of the paper or other background, while black results from a full combination of colored inks. To save money on ink, and to produce deeper black tones, unsaturatedand dark colors are produced by using black ink instead of the combination of cyan, magenta and yellow. REFERENCE{https://en.wikipedia.org/wiki/CMYK_color_model}
HSV COLOUR MODEL HSL and HSV are the two most common cylindrical-coordinate representations of points in an RGB color model. The two representations rearrange the geometry of RGB in an attempt to be more intuitive and perceptually relevant than the cartesian (cube) representation. Developed in the 1970s for computer graphics applications, HSL and HSV are used today in color pickers, in image editing software, and less commonly in image analysis and computer vision. HSL stands for hue, saturation, and lightness, and is often also called HLS. HSV stands for hue, saturation, and value, and is also often called HSB (B for brightness). A third model, common in computer vision applications, is HSI, for hue, saturation, and intensity. However, while typically consistent, these definitions are not standardized, and any of these abbreviations might be used for any of these three or several other related cylindrical models. (For technical definitions of these terms, see below.) In each cylinder, the angle around the central vertical axis corresponds to "hue", the distance from the axis corresponds to "saturation", and the distance along the axis corresponds to "lightness", "value" or "brightness". Note that while "hue" in HSL and HSV refers to the same attribute, their definitions of "saturation" differ dramatically. Because HSL and HSV are simple transformations of device-dependent RGB models, the physical colors they define depend on the colors of the red, green, and blue primaries of the device or of the particular RGB space, and on the gamma correction used to represent the amounts of those primaries. Each unique RGB device therefore has unique HSL and HSV spaces to accompany it, and numerical HSL or HSV values describe a different color for each basis RGB space.[1] Both of these representations are used widely in computer graphics, and one or the other of them is often more convenient than RGB, but both are also criticized for not adequately separating color-making attributes, or for their lack of perceptual uniformity. REFERENCE{https://en.wikipedia.org/wiki/HSL_and_HSV |
||||||||||||||||||||||||||||||
|
|
`
