C()/\/\PUTER SC!E/\/CE E/\/G!NEER!/\/G

CREATE A JAVA PROGRAM WITHOUT MAIN METHOD

2012-01-26T22:30:00.000+05:30

class Cool
{
static
{
System.out.println("This java program have run without the run method");
System.exit(0);

}
}

AS THE MAIN BLOCK EXECUTES THE STATIC BLOCK FIRST, IT ENCOUNTERS STATIC BLOCK AND EXECUTES THE STATEMENTS PRESENT. BUT IT THROWS A EXCEPTION AS THERE IS NO MAIN METHOD. TO ERADICATE THIS WE USE SYSTEM.EXIT(0) STATEMENT TO EXIT FROM THE PROGRAM FORCIBLY.

differences between java and c++ #4

2012-01-04T13:16:00.001+05:30

difference between java and c++ #3

2012-01-04T13:15:00.002+05:30

Java can be run anywhere that's the main difference and it available freely. Java has desighn netbeans to support for designing like to to do any project but i n C++ the project is rather tough to built as it doesn't support GUI.

Java uses both Complier and interpreter.

Java is an pure object oriented programming language, it uses the concepts of Classes, Objects, Inheritance, Polymorphism. And the execution of a program is non-linear.
It is so called because you can't write a program with out using classes & objects.

When you compile a Java program, an intermediate bytecode is generated, which itself is interpreted by the Java Virtual Machine. This way you write a program once, and the virtual machine translates the bytecode into instructions a specific processor can understand. Execution of a Java program is by consequence a bit slow, because the intermediate bytecode has to be interpreted.

Java uses a "Garbage Collector" which manages memory automatically so the programmer doesn't have to handle that.

Variables in Java can be declared anywhere in a program. (Although it is recommended to declare/define them at the beginning of blocks).
Reuse of code achieved by inheritance.
By default members are private.
During the execution of bytecode by JVM, it does not substitute the entire classes of package which are imported in the program. It just enters the package and executes the class and returns result in to the program. Due to this less memory is used by java program.

C uses concept of structures (not object oriented).
In C we use the concept of pointers whereas there are no pointers used in JAVA
In C the programmer needs to manage memory manually. "malloc()" and "free()" are the fundamental memory allocation library calls.
In C the declaration of variables should be on the beginning of the block.
C supports go to statement, struct and union unlike Java
C is compiled to the machines "native language" so it's execution is much faster than Java's.
No reuse in code and by default members are public.
C programs will have a larger memory footprint than an equivalent program written in pure machine code, but the total memory use of a C program is much smaller than the a Java program because C does not require the loading of an execution interpreter like the JVM.
--------------------------------------------------------------------------------------------

Java
Java is an pure object oriented programming language, it uses the concepts of Classes, Objects, Inheritance, Polymorphism. And the execution of a program is non-linear.
It is so called because you can't write a program with out using classes & objects.

Java's motto (so to speak) is "write once run anywhere".
When you compile a Java program, an intermediate bytecode is generated, which itself is interpreted by the Java Virtual Machine. This way you write a program once, and the virtual machine translates the bytecode into instructions a specific processor can understand. Execution of a Java program is by consequence a bit slow, because the intermediate bytecode has to be interpreted.

Java uses a "Garbage Collector" which manages memory automatically so the programmer doesn't have to handle that.

Variables in Java can be declared anywhere in a program. (Although it is recommended to declare/define them at the beginning of blocks).
Reuse of code achieved by inheritance.
By default members are private.
During the execution of bytecode by JVM, it does not substitute the entire classes of package which are imported in the program. It just enters the package and executes the class and returns result in to the program. Due to this less memory is used by java program.

C
C uses concept of structures (not object oriented).
In C we use the concept of pointers whereas there are no pointers used in JAVA
In C the programmer needs to manage memory manually. "malloc()" and "free()" are the fundamental memory allocation library calls.
In C the declaration of variables should be on the beginning of the block.
C supports go to statement, struct and union unlike Java
C is compiled to the machines "native language" so it's execution is much faster than Java's.
No reuse in code and by default members are public.
C programs will have a larger memory footprint than an equivalent program written in pure machine code, but the total memory use of a C program is much smaller than the a Java program because C does not require the loading of an execution interpreter like the JVM.

difference between java and c++---2

2012-01-04T13:14:00.002+05:30

Java does not support typedefs, defines, or a preprocessor. Without a preprocessor, there are no provisions for including header files.
Since Java does not have a preprocessor there is no concept of #define macros or manifest constants. However, the declaration of named constants is supported in Java through use of the final keyword.
Java does not support enums but, as mentioned above, does support named constants.
Java supports classes, but does not support structures or unions.
All stand-alone C++ programs require a function named main and can have numerous other functions, including both stand-alone functions and functions, which are members of a class. There are no stand-alone functions in Java. Instead, there are only functions that are members of a class, usually called methods. Global functions and global data are not allowed in Java.
All classes in Java ultimately inherit from the Object class. This is significantly different from C++ where it is possible to create inheritance trees that are completely unrelated to one another.
All function or method definitions in Java are contained within the class definition. To a C++ programmer, they may look like inline function definitions, but they aren't. Java doesn't allow the programmer to request that a function be made inline, at least not directly.
Both C++ and Java support class (static) methods or functions that can be called without the requirement to instantiate an object of the class.
The interface keyword in Java is used to create the equivalence of an abstract base class containing only method declarations and constants. No variable data members or method definitions are allowed. (True abstract base classes can also be created in Java.) The interface concept is not supported by C++.
Java does not support multiple inheritance. To some extent, the interface feature provides the desirable features of multiple inheritance to a Java program without some of the underlying problems.
While Java does not support multiple inheritance, single inheritance in Java is similar to C++, but the manner in which you implement inheritance differs significantly, especially with respect to the use of constructors in the inheritance chain.
In addition to the access specifiers applied to individual members of a class, C++ allows you to provide an additional access specifier when inheriting from a class. This latter concept is not supported by Java.
Java does not support the goto statement (but goto is a reserved word). However, it does support labeled break and continue statements, a feature not supported by C++. In certain restricted situations, labeled break and continue statements can be used where a goto statement might otherwise be used.
Java does not support operator overloading.
Java does not support automatic type conversions (except where guaranteed safe).
Unlike C++, Java has a String type, and objects of this type are immutable (cannot be modified). Quoted strings are automatically converted into String objects. Java also has a StringBuffer type. Objects of this type can be modified, and a variety of string manipulation methods are provided.
Unlike C++, Java provides true arrays as first-class objects. There is a length member, which tells you how big the array is. An exception is thrown if you attempt to access an array out of bounds. All arrays are instantiated in dynamic memory and assignment of one array to another is allowed. However, when you make such an assignment, you simply have two references to the same array. Changing the value of an element in the array using one of the references changes the value insofar as both references are concerned.
Unlike C++, having two "pointers" or references to the same object in dynamic memory is not necessarily a problem (but it can result in somewhat confusing results). In Java, dynamic memory is reclaimed automatically, but is not reclaimed until all references to that memory become NULL or cease to exist. Therefore, unlike in C++, the allocated dynamic memory cannot become invalid for as long as it is being referenced by any reference variable.
Java does not support pointers (at least it does not allow you to modify the address contained in a pointer or to perform pointer arithmetic). Much of the need for pointers was eliminated by providing types for arrays and strings. For example, the oft-used C++ declaration char* ptr needed to point to the first character in a C++ null-terminated "string" is not required in Java, because a string is a true object in Java.
A class definition in Java looks similar to a class definition in C++, but there is no closing semicolon. Also forward reference declarations that are sometimes required in C++ are not required in Java.
The scope resolution operator (::) required in C++ is not used in Java. The dot is used to construct all fully-qualified references. Also, since there are no pointers, the pointer operator (->) used in C++ is not required in Java.
In C++, static data members and functions are called using the name of the class and the name of the static member connected by the scope resolution operator. In Java, the dot is used for this purpose.
Like C++, Java has primitive types such as int, float, etc. Unlike C++, the size of each primitive type is the same regardless of the platform. There is no unsigned integer type in Java. Type checking and type requirements are much tighter in Java than in C++.
Unlike C++, Java provides a true boolean type.
Conditional expressions in Java must evaluate to boolean rather than to integer, as is the case in C++. Statements such as if(x+y)... are not allowed in Java because the conditional expression doesn't evaluate to a boolean.
The char type in C++ is an 8-bit type that maps to the ASCII (or extended ASCII) character set. The char type in Java is a 16-bit type and uses the Unicode character set (the Unicode values from 0 through 127 match the ASCII character set). For information on the Unicode character set see http://www.stonehand.com/unicode.html.
Unlike C++, the >> operator in Java is a "signed" right bit shift, inserting the sign bit into the vacated bit position. Java adds an operator that inserts zeros into the vacated bit positions.
C++ allows the instantiation of variables or objects of all types either at compile time in static memory or at run time using dynamic memory. However, Java requires all variables of primitive types to be instantiated at compile time, and requires all objects to be instantiated in dynamic memory at runtime. Wrapper classes are provided for all primitive types except byte and short to allow them to be instantiated as objects in dynamic memory at runtime if needed.
C++ requires that classes and functions be declared before they are used. This is not necessary in Java.
The "namespace" issues prevalent in C++ are handled in Java by including everything in a class, and collecting classes into packages.
C++ requires that you re-declare static data members outside the class. This is not required in Java.
In C++, unless you specifically initialize variables of primitive types, they will contain garbage. Although local variables of primitive types can be initialized in the declaration, primitive data members of a class cannot be initialized in the class definition in C++.
In Java, you can initialize primitive data members in the class definition. You can also initialize them in the constructor. If you fail to initialize them, they will be initialized to zero (or equivalent) automatically.
Like C++, Java supports constructors that may be overloaded. As in C++, if you fail to provide a constructor, a default constructor will be provided for you. If you provide a constructor, the default constructor is not provided automatically.
All objects in Java are passed by reference, eliminating the need for the copy constructor used in C++.
(In reality, all parameters are passed by value in Java. However, passing a copy of a reference variable makes it possible for code in the receiving method to access the object referred to by the variable, and possibly to modify the contents of that object. However, code in the receiving method cannot cause the original reference variable to refer to a different object.)
There are no destructors in Java. Unused memory is returned to the operating system by way of a garbage collector, which runs in a different thread from the main program. This leads to a whole host of subtle and extremely important differences between Java and C++.
Like C++, Java allows you to overload functions. However, default arguments are not supported by Java.
Unlike C++, Java does not support templates. Thus, there are no generic functions or classes.
Unlike C++, several "data structure" classes are contained in the "standard" version of Java. More specifically, they are contained in the standard class library that is distributed with the Java Development Kit (JDK). For example, the standard version of Java provides the containers Vector and Hashtable that can be used to contain any object through recognition that any object is an object of type Object. However, to use these containers, you must perform the appropriate upcasting and downcasting, which may lead to efficiency problems.
Multithreading is a standard feature of the Java language.
Although Java uses the same keywords as C++ for access control: private, public, and protected, the interpretation of these keywords is significantly different between Java and C++.
There is no virtual keyword in Java. All non-static methods always use dynamic binding, so the virtual keyword isn't needed for the same purpose that it is used in C++.
Java provides the final keyword that can be used to specify that a method cannot be overridden and that it can be statically bound. (The compiler may elect to make it inline in this case.)
The detailed implementation of the exception handling system in Java is significantly different from that in C++.
Unlike C++, Java does not support operator overloading. However, the (+) and (+=) operators are automatically overloaded to concatenate strings, and to convert other types to string in the process.
As in C++, Java applications can call functions written in another language. This is commonly referred to as native methods. However, applets cannot call native methods.
Unlike C++, Java has built-in support for program documentation. Specially written comments can be automatically stripped out using a separate program named javadoc to produce program documentation.
Generally Java is more robust than C++ due to the following:
Object handles (references) are automatically initialized to null.
Handles are checked before accessing, and exceptions are thrown in the event of problems.
You cannot access an array out of bounds.
Memory leaks are prevented by automatic garbage collection.

DIFFERENCE BETWEEN JAVA AND C++

2012-01-04T13:12:00.002+05:30

Although both are object oriented programming language and Java was derived from C++ but still there is big difference between these two languages.

You can see the actual difference once you start programming on it.

But here i am going to give you few differences between these two...

1. Java does not support operator overloading

2. A class definition in Java looks similar to a class definition in C++, but there is no closing semicolon.

3. Forward reference declarations are not required in Java.

4. Scope resolution operator (::) required in C++ is but not in Java.

4. In C++ you have to re-declare static data members outside the class but such things are not required in Java
--------------------------------------------------------------------------

Everything is an object in Java (Single root hierarchy as everything gets derived from java.lang.Object).
Java does not have all the complicated aspects of C++ ( For ex: Pointers, templates, unions, operator overloading, structures etc..) The Java language promoters initially said "No pointers!", but when many programmers questioned how you can work without pointers, the promoters began saying "Restricted pointers." You can make up your mind whether it’s really a pointer or not.

In any event, there’s no pointer arithmetic. There are no destructors in Java (automatic garbage collection). Java does not support conditional compile (#ifdef/#ifndef type).

Thread support is built into java but not in C++. Java does not support default arguments. There’s no scope resolution operator :: in Java. Java uses the dot for everything, but can get away with it since you can define elements only within a class. Even the method definitions must always occur within a class, so there is no need for scope resolution there either. There’s no "goto " statement in Java. Java doesn’t provide multiple inheritance (MI), at least not in the same sense that C++ does. Exception handling in Java is different because there are no destructors. Java has method overloading, but no operator overloading. The String class does use the + and += operators to concatenate strings and String expressions use automatic type conversion, but that’s a special built-in case. Java is interpreted for the most part and hence platform independent.

HTML TAG LIST

2011-11-23T17:17:00.003+05:30

NOW HERE IN THIS PART LET US JUST KNOW THE BASIC HTML TAGS THAT ARE PRESENT FOR THE CREATION OF AN HTML PAGE.....

NOW CHECK THIS LINK

CLICK HERE

google- 3 yrs old

2011-09-03T13:36:00.000+05:30

Google Chrome, now the third most popular Web browser in the world after Mozilla's Firefox and Microsoft's Internet Explorer which completed its three years on 1 September.

In order to celebrate the day, Google released an infographic that documents the evolution of the Web, which starts from Mosaic to the latest Chromebook.
The browser grabbed 15 per cent market share during these years. Ben Goodger and Darin Fisher, software engineers, said that the browser will continue to innovate and improve. It will have regular updates every six weeks.

Chrome has increased its speed with the V8 JavaScript engine. Its omnibox is also improved now and helps in suggesting partial matches for URLs and webpage titles.

The browser also supports many popular screen readers, which include, JAWS, NVDA and VoiceOver. These features make it simple for even the visually impaired people to experience the Web better.

Also, an integrated and sandboxed PDF viewer helps a user to view PDF files on the Web. The user need not install any additional software, which helps improve the overall security.

Sutherland–Hodgman algorithm

2010-10-06T18:34:00.000+05:30

The algorithm begins with an input list of all vertices in the subject polygon. Next, one side of the clip polygon is extended infinitely in both directions, and the path of the subject polygon is traversed. Vertices from the input list are inserted into an output list if they lie on the visible side of the extended clip polygon line, and new vertices are added to the output list where the subject polygon path crosses the extended clip polygon line.

This process is repeated iteratively for each clip polygon side, using the output list from one stage as the input list for the next. Once all sides of the clip polygon have been processed, the final generated list of vertices defines a new single polygon that is entirely visible. Note that if the subject polygon was concave at vertices outside the clipping polygon, the new polygon may have coincident (i.e. overlapping) edges – this is acceptable for rendering, but not for other applications such as computing shadows.

PSEUDO CODE:-

List outputList = subjectPolygon;
  for (Edge clipEdge in clipPolygon) do
     List inputList = outputList;
     outputList.clear();
     Point S = inputList.last;
     for (Point E in inputList) do
        if (E inside clipEdge) then
           if (S not inside clipEdge) then
              outputList.add(ComputeIntersection(S,E,clipEdge));
           end if
           outputList.add(E);
        else if (S inside clipEdge) then
           outputList.add(ComputeIntersection(S,E,clipEdge));
        end if
        S = E;
     done
  done

CLIPPING PLANE

2010-10-06T18:25:00.000+05:30

Clipping planes can be used in addition of those used created for the viewing volume. OpenGL define 6 clipping plane GL_CLIP_PLANEi (i goes from 0 to 5).
A clipping plane is a plane that separate the space in two regions. One region is included from the viewing volume, the other is excluded.

In mathematics, a plane is defined by this equation :
    a*x+b*y+c*z+d = 0
(x, y, z) are the coordinates of the points in the 3D space. All points that verify this equation are on the plane.
The inequality (< or > instead of =) define the region in each side of the plane.

In OpenGL, a clipping plane is the region defined by this equation :
    a*x+b*y+c*z+d >= 0
A clipping plane is creates with the 4 values a, b, c & d likethis :
    double[] eq = {a, b, c, d}
    gl.glClipPlane(GL_CLIP_PLANEi, eq)

All points draw , the other are excluded (will not be rendered on the screen).

Like for lights, clipping planes have to be enable to be active :
    gl.glEnable(GL_CLIP_PLANEi)

ORTHOGRAPHIC PROJECTION

2010-10-06T18:23:00.001+05:30

The Viewing Volume shape in this case is a parallelepiped. The 6 clipping planes delimiting the space can be created with the aid of :
gl.glOrtho(left, right, bottom, top, near, far)

VIEW VOLUME LOOKS LIKE:-

PERSPECTIVE PROJECTION

2010-10-06T18:22:00.002+05:30

With this kind of projection, the viewing volume shape is a truncated pyramid (its top is cutted).

This shape is abtained by 6 cutting planes : front, back, right, left, top and bottom planes (planes at the volume boundary). These planes are commonly called Clipping Planes. These planes can be created with the aid of the method :
glu.gluPerspective(fovy, aspect, near, far)
The fovy parameter is the angle between the plane that goes downwards and the plane that goes upwards.
The aspect ratio is generaly the aspect ratio of the window (window is the region of the screen in which the scene is rendered).

VIEWING VOLUME

2010-10-06T18:20:00.002+05:30

The 3D space is defined by 3 axis (vectors) : X, Y and Z. These 3 axis creates an axis system (see Tutorial 4for a representation of this axis system). All points of the 3D space can be expressed as a linear combination of these vectors. A point is point represented by its coordinates (x, y, z), which means x * X + y * Y + z * Z (upper case is a vector, low case is a scalar). The volume of the entire 3D space is infinity.

The Viewing Volume delimites the 3D space by creating a closed volume. Points outside this volume will not appears on the screen.
This particularity explain the first call glTranslate (just after glLoadIdentity) : we go inside the Viewing Volume. At start, we are on the front plane of the viewing volume.

The Viewing Volume can be created with two different kind of projections :
Perspective Projection Render object affected by the distance, a car is seen smaller when it move away.
Orthographic Projection Render object NOT affected by the distance like a menu, a text on the screen, 2D objects ...

CLIPPING ALGORITHMS

2010-10-05T17:33:00.005+05:30

• Clipping eliminates the parts of a scene that aren’t going to be visible in the
final display.

• Clipping can be applied to various types of graphics objects.
– Points – this is basically trivial; check to see that the point coordinates are
between the clipping boundaries.
– Lines
– Fill Areas
– Curves
– Text

• The first three are standard in graphics packages.

• Most of the algorithms apply to rectangular clipping regions

MODIFYING WINDOW PROPERTIES

2010-10-05T17:33:00.002+05:30

• You can control how the window is reshaped by defining a reshape function
and setting it as the reshape callback using
glutReshapeFunc( winReshapeFunc);

• You can modify the size and shape of the current window using
glutPositionWindow( xNewTopLeft, yNewTopLeft);
glutReshapeWindow( newWidth, newHeight);

• Change the window title with
glutSetWindowTitle( newTitle);

• Specify the cursor with
glutSetCursorShape( shape);
Use symbolic constants like GLUT_CURSOR_UP_DOWN to specify the shapes. (Exact
shapes available are system specific.)

USING MULTIPLE WINDOWS

2010-10-05T17:32:00.001+05:30

• Create multiple windows by doing the same sequence of steps for each window.

• You need to keep track of the window ID to be able to go back to a particular
window.
glutSetWindow(windowID);
is used to make a particular window active.

• You can destroy a window when you are done with it.
glutDestroyWindow( windowID);

• The current window ID can be obtained using
glutGetWindow();

DISPLAY WINDOWS IN OPEN GL

2010-10-05T17:31:00.001+05:30

• Don’t forget to initialize GLUT with glutInit.

• Create a window of specified size in a particular position on the screen with
glutInitWindowPosition( xTopLeft, yTopLeft);
glutInitWindowSize( dwWidth, dwHeight);
glutCreateWindow( "Title");

• Default position is (−1,−1) which allows the window system to choose the
position.

• Default size is 300 pixels square.

• glutCreateWindow returns an integer id for the window. You only need this
if you are displaying more than one window.

VIEWPORTS IN OPEN GL

2010-10-05T17:30:00.000+05:30

• To specify the viewport parameters, do
glViewport( xvmin, yvmin, vpWidth, vpHeight)
with parameters given in integer screen coordinates. The first two give the
position of the lower left corner relative to the lower left corner of the display
window.

• By default, the viewport is the entire window. window.

• You can create multiple viewports within a window.

• To get the parameters for the active viewport, use
glGetIntegerv( GL_VIEWPORT, vpArray);
where vpArray is a 4 element integer array. The contents of vpArray after
the function returns will be the same as the arguments given to glViewport
in the same order

2D VIEWING IN OPEN GL

2010-10-05T17:29:00.002+05:30

• The basic library does everything in 3D.
– The 3D routines can be adapted to 2D
– A viewport function is provided.

• To define clipping windows and viewports, first go to projection mode.
glMatrixMode( GL_PROJECTION);
If necessary, use glLoadIdentity to initialize the matrix.

• A 2D clipping window can be defined with
gluOtrho2D( xwmin,xwmax, ywmin,ywmax)

• Normalized coordinates are from −1 to 1 in OpenGL. This is the default
clipping window.

2D RENDERING PIPELINE

2010-10-05T17:25:00.005+05:30

2D VIEWING TRANSFORMATION

2010-10-05T17:25:00.002+05:30

2D COORDINATE SYSTEM

2010-10-05T17:24:00.002+05:30

• We use modeling coordinates for individual parts of a 2D scene. For example,
your polygon function put the polygon at the origin with a “radius” of 1.
Those were modeling coordinates.

• World coordinates are used for organizing the parts into a scene.

• View coordinates are the coordinates within the desired viewport which is
somewhere within the window you are using.

• Normalized coordinates are between 0 and 1 or -1 and 1 in each direction.
They are used to make the viewing process independent of the output device.

• Device coordinates are relative to the actual display area on whatever device
you are using.

2D TRANSFORMATIONS

2010-10-05T17:23:00.000+05:30

The ability to perform transformations on objects in an image is an important feature of a graphics system. Operators were added to this system which allow the user to create 2D transformation matrices that perform the following transformations:

scale around (0, 0)
scale around an arbitrary point, with the x-scale direction oriented to a specified angle
translate
rotate around (0, 0)
rotate around an arbitrary point

In addition, helper functions were created that perform matrix multiplication, reset a matrix to the identity, reset a matrix to the zero matrix, and print a matrix. Below are some sample images created using these methods. The original polygons are in red, and the tranformed ones are in blue. The images are of translation, rotation of PI/4 about (0, 0), rotation of PI/4 about (80, 40), scaling by .8 in x and y, and respectively.

3D AND ANIMATION

2010-10-04T19:49:00.000+05:30

3D computer graphics

3D computer graphics in contrast to 2D computer graphics are graphics that use a three-dimensional representation of geometric data that is stored in the computer for the purposes of performing calculations and rendering 2D images. Such images may be for later display or for real-time viewing.

Despite these differences, 3D computer graphics rely on many of the same algorithms as 2D computer vector graphics in the wire frame model and 2D computer raster graphics in the final rendered display. In computer graphics software, the distinction between 2D and 3D is occasionally blurred; 2D applications may use 3D techniques to achieve effects such as lighting, and primarily 3D may use 2D rendering techniques.

3D computer graphics are often referred to as 3D models. Apart from the rendered graphic, the model is contained within the graphical data file. However, there are differences. A 3D model is the mathematical representation of any three-dimensional object. A model is not technically a graphic until it is visually displayed. Due to 3D printing, 3D models are not confined to virtual space. A model can be displayed visually as a two-dimensional image through a process called 3D rendering, or used in non-graphical computer simulations and calculations.

Computer animation

Computer animation is the art of creating moving images via the use of computers. It is a subfield of computer graphics and animation. Increasingly it is created by means of 3D computer graphics, though 2D computer graphics are still widely used for stylistic, low bandwidth, and faster real-time rendering needs. Sometimes the target of the animation is the computer itself, but sometimes the target is another medium, such as film. It is also referred to as CGI (Computer-generated imagery or computer-generated imaging), especially when used in films.

Virtual entities may contain and be controlled by assorted attributes, such as transform values (location, orientation, and scale) stored in an object's transformation matrix. Animation is the change of an attribute over time. Multiple methods of achieving animation exist; the rudimentary form is based on the creation and editing of keyframes, each storing a value at a given time, per attribute to be animated. The 2D/3D graphics software will interpolate between keyframes, creating an editable curve of a value mapped over time, resulting in animation. Other methods of animation include procedural and expression-based techniques: the former consolidates related elements of animated entities into sets of attributes, useful for creating particle effects and crowd simulations; the latter allows an evaluated result returned from a user-defined logical expression, coupled with mathematics, to automate animation in a predictable way (convenient for controlling bone behavior beyond what a hierarchy offers in skeletal system set up).

To create the illusion of movement, an image is displayed on the computer screen then quickly replaced by a new image that is similar to the previous image, but shifted slightly. This technique is identical to the illusion of movement in television and motion pictures.

2D COMPUTER GRAPHICS

2010-10-04T19:45:00.000+05:30

2D computer graphics are the computer-based generation of digital images—mostly from two-dimensional models, such as 2D geometric models, text, and digital images, and by techniques specific to them. The word may stand for the branch of computer science that comprises such techniques, or for the models themselves.

2D computer graphics are mainly used in applications that were originally developed upon traditional printing and drawing technologies, such as typography, cartography, technical drawing, advertising, etc.. In those applications, the two-dimensional image is not just a representation of a real-world object, but an independent artifact with added semantic value; two-dimensional models are therefore preferred, because they give more direct control of the image than 3D computer graphics, whose approach is more akin to photographythan to typography.

Pixel art

Pixel art is a form of digital art, created through the use of raster graphics software, where images are edited on the pixel level. Graphics in most old (or relatively limited) computer and video games, graphing calculator games, and many mobile phone games are mostly pixel art.

Vector graphics

Vector graphics formats are complementary to raster graphics, which is the representation of images as an array of pixels, as it is typically used for the representation of photographic images. There are instances when working with vector tools and formats is best practice, and instances when working with raster tools and formats is best practice. There are times when both formats come together. An understanding of the advantages and limitations of each technology and the relationship between them is most likely to result in efficient and effective use of tools.

COMPUTER GRAPHICS

2010-10-04T19:41:00.000+05:30

The term computer graphics has been used in a broad sense to describe "almost everything on computers that is not text or sound". Typically, the termcomputer graphics refers to several different things:

the representation and manipulation of image data by a computer
the various technologies used to create and manipulate images
the images so produced, and
the sub-field of computer science which studies methods for digitally synthesizing and manipulating visual content, see study of computer graphics

Compute graphics is the life line of today's computer world. Today, computers and computer-generated images touch many aspects of daily life. Computer imagery is found on television, in newspapers, for example in weather reports, or for example in all kinds of medical investigation and surgical procedures. A well-constructed graph can present complex statistics in a form that is easier to understand and interpret. In the media "such graphs are used to illustrate papers, reports, theses", and other presentation material.

Many powerful tools have been developed to visualize data. Computer generated imagery can be categorized into several different types: 2D, 3D, 5D, and animated graphics. As technology has improved, 3D computer graphics have become more common, but 2D computer graphics are still widely used. Computer graphics has emerged as a sub-field of computer science which studies methods for digitally synthesizing and manipulating visual content. Over the past decade, other specialized fields have been developed like information visualization, and scientific visualization more concerned with "the visualization of three dimensional phenomena (architectural, meteorological, medical, biological, etc.), where the emphasis is on realistic renderings of volumes, surfaces, illumination sources, and so forth, perhaps with a dynamic (time) component".