If you have an artistic hand but don’t know how to write, or you have beautiful voice and you don’t know how to sing, you may have a gift, but a paralyzed one.

You have a website and don’t know what its composition is; you have graphics and don’t know how they are designed; just the lack of this information you may lose your business.

Simple, yet complex, are the pages of your website containing graphics all together in every space. And those very graphics can hamper you, if not properly designed for an impressive deliverance to the customer.

If your site loads slowly in a browser, if your logos are not eye pleasing, if the fonts are not stylish, if the color combination and outline architecture is not smooth, you might be irritating your own costumer rather appealing to them.

Graphic design

Vector graphics is a geometric modeling of images, widely being used in Computer Graphics today. Vector graphics applies geometrical standards i.e., lines, curves, and polygons to represent images, while Raster graphics or a bit-mapped image, which is based on pixels in a grid, and contains information about the colors to be displaced in "bits". Due to this raster graphics have fixed resolution, thus cannot be resized without losing image quality.

In addition, bitmap images have much large file sizes; however, vector graphics are prepared by many individual objects, and each of them are defined by geometrical data with individual properties allocated to it such as color, fill, and outline. Thus, vector graphics have free resolution and can bring high quality output at any scale.

Vector images are more flexible than bitmaps, and for that reason they can be resized and stretched. Additionally, images stored as vectors enhance appearances on monitors and printers with higher resolution, while bit-mapped images always appear the same, in spite of of a device’s resolution. Another advantage of vector graphics is it requires less memory than bit-mapped images do.

The word vector graphics is typically used in the context of two-dimensional computer graphics. Today almost all computer video displays transform vector representations of an image to a raster format.

Vector graphics editors usually allow a user to spin, shift, mirror, stretch, tilt, a combination of primitives into a more sophisticated objects. Vector graphics are better for designing outlines, typography, logos, technical illustrations, diagram and flowchart, while bitmap editors are more suitable for retouching photos, photo processing, and artistic illustrations.

It is ideally good for simple or complex drawings that need to be photo-realism. i.e., for PostScript and PDF page description languages use a vector graphics model. Vector graphic are perfect format for the Web as these are lightweight graphics to the websites due to its file size and problem free regarding physical height and width of the image.

These days, websites are filled with sophisticated icons, images, navigation bars, photographs, bottoms, logos, etc and for cutting the file size, vector graphics are efficient, smaller, compact, and scale perfect or independent resolution compare to the raster graphics.

Regarding programs which allows us to create and operate vector graphics, are called drawing programs, while programs that operate bit-mapped images are called paint programs.

Almost all graphics application these days, including CADD systems and animation software, use vector graphics; furthermore, printers like PostScript printers use vector graphics and fonts represent as vectors are called postscript fonts. While, dot-matrix printers, laser printers, and monitors, are raster devices, this means that all objects, even vector objects, must be translated into bit maps before being output which means, even vector graphic images must be interpreted to the raster graphic before the end product can be displayed on paper.

Interesting, yet most important note regarding these two graphics are, its similarity with the human organ behaviors; like bitmap images, the human eyes catches objects in a mosaic raster format by photon recipient nerves though physical world.

Another hand brain function perceives the objects as vector graphics in its visual world. As a result, the brain can easily recalls drawings like cartoon, logos, signs, images, symbols, banners, with outlines. Though the pixel image with mosaic format will be faded out, but the impression of outlines of the pictures will remain in the memory of a human being for long. Eyes cannot manipulate the objects seen in the outer world, it perceives as it is, while the mind can manipulate through its imagination in its mental zone.

If you have chosen the right graphics and the right graphic designer for your business, enrich your business with graphics that are web friendly, swift loading, attractive, impressive and much more than outlines that remain in the mind of your visitor for a very long time.

Your website design should be eye pleasing, mind snatching, impressive and overall appealing to the customers. Design simple, but yet make it striking!

Tag:

Add to Del.icio.us | Digg | Yahoo! My Web | Furl

Bookmark WebProNews:

Bharat Bista
Resources and References: Graphic Design – Custom Web Site Design – Silk Flowers

If your values require more than byte sized bits, the bits you require can still be packed more efficiently; if you need 10 bits, you can pack eight of those in an ten byte string (rather than the 16 or 32 bytes you might otherwise use).

The use of vector in this context probably came from jump tables: the bits represent a place for code to jump to, and therefor are at least vaguely related to the physics/engineering definition of a vector quantity (maginitude and direction). I still think of these as bit maps or bit fields, but apparently I’m out of touch.

Perl has the “vec” function for bit fields. Its granularity is a little bit limited: the number of bits you want to examine or set has to be a power of 2, so you can’t (for example) conveniently work with three bit fields. You’d need to use four bits, a small waste, or handle all the nasty details yourself with substr and << >> operators. Using “vec” is a lot more pleasant. Here’s an example sets some individual bits, and reads them back from the string.

#!/usr/bin/perl
my $bitf;
vec($bitf,0,1)=1;
vec($bitf,1,4)=7;
for($x=0;$x < 8;$x++) {
print "$x ",vec($bitf,$x,1), "\n";
}
# another way to print out a bit field
print unpack("b*", $bitf), "\n";
That produces:

0&nbsp 1
1 &nbsp0
2 &nbsp0
3 &nbsp0
4 &nbsp1
5 &nbsp1
6 &nbsp1
7 &nbsp0
10001110

If you don't see why setting bits 4 to 7 as 7 produces "110", it's just simple banary, starting from bit 4: bit 4 has the value of 1 if set, bit 5 has 2, bit 6 has 4.

*Originally published at APLawrence.com

A.P. Lawrence provides SCO Unix and Linux consulting services http://www.pcunix.com

Illustrator is used to open and manipulate vector-based drawing. Vector-based images are series of points connected by lines. It is also called object-oriented or draw images. It uses geometrical formulas to represent images.

Vector files have graphical elements called objects. These objects have properties including color, shape, outline, size, and position on the screen as well as the definition of the object. It is also a self-contained entity, which means that the properties of the object can be moved and changed without affecting the other objects while the clarity and crispness are preserved. This characteristic makes a vector-based image suitable for illustration and 3D modeling. An image is created by connecting vector point with straight or curved lines. Vector point or anchor point is the basis and the most fundamental component in every vector image

Unlike bitmap images, vector-based images are resolution dependent. The quality of the image increases as the resolution increases. So it looks better on devices with higher resolution. It can also be resized and stretched and does not become grainy. Since bitmap images are composed of dots, it losses its quality and proportion when stretched.

Vector images can also be converted to bitmap images. Almost all graphics system and animation software use vector graphics because it can be manipulated.

Importing of vector images into EPS, GIF or JPEG is not a problem. Vector images created by Illustrator or Freehand are composed of multiple objects. This allows the EPS (Encapsulated PostScript) vector image to be reduced or enlarged without sacrificing the quality.

Vector images are commonly used in GIF or Graphical Interchange Format files because they both consume a small file size, which is an advantage in Web page making.

JPEG (Joint Photographic Experts Group), mostly photographic images that undergoes editing, use vector images because of its resolution dependency.

If you want to make graphs and charts for presentations and printed publication, Illustrator is the right tool. You can also convert scanned art line into vector artwork. It is also used to rotate, distort and create special effects with text. However, Illustrator is not suited for page layout programs. A page layout program is where you make your catalogs, brochures, etc. You can import text or type text directly into the page layout document.

For additional information about the article log on to http://www.shortrunondemandprinting.com

admin@shortrunondemandprinting.com

Sounds more like a science project than a computer program, but the ray tracing algorithm is pure mathematics (geometry and algebra). The sphere is the simplest object to ray trace, because the sphere can be described in one simple formula, where other shapes such as a cube need to be described as the combination of several planes. The formula for the sphere is:

The majority of calculation in Ray Tracing is in finding a method to test for the intersection point of the object you are viewing. By the way, we are not concerned with speed in this program. If we were concerned with speed, we would use a watered-down version of ray tracing known as ray casting which is the technique used to form the graphics you see in Doom, Quake, Duke Nukem and other animation software that requires quick rendering.

The basic equation for a ray (or line) in 3D space is shown below:

You can almost think of it as the formula of a line in 3d space where R_o is the y intercept and R_d is the slope. Now let’s look at a use case of the ray tracing algorithm

1. For each pixel on the surface of a 2-D screen that the eye or camera is viewing, determine the world coordinates of the pixel.
2. Cast a ray from the “camera” through the pixel
3. Check for an intersection with a solid object (in this case a sphere.)
4. For the nearest intersection with the solid object, determine a shade corresponding to the distance of the ray to the object.

Let’s look at the math in the algorithm and take a look at the Ray tracing formula broken up into its Cartesian coordinates:

x(t) = xo + xd * t (t > 0) y(t) = yo + yd * t z(t) = zo + zd * t

If we now substitute the ray formula into the equation for a sphere we get:

(xo + xd * t – xc)2 + (yo + yd * t – yc)2 + (zo + zd * t – zc)2 – rs2 = 0

This formula can be solved for t by using the quadratic equation where:

So by the quadratic formula :

The discriminant B² – 4C must be greater than zero or there is no intersection (B² – 4C < 0 produces an imaginary root). Also we are only interested in the smallest root solution of t that is greater than zero. Even if the larger root of t is positive, this root would be passing through the opposite side of the sphere, which is the side we cannot see, so we throw this root out.

Now we have everything we need to determine the point of intersection and then the Normal vector. The normal vector is the vector perpendicular to the ray of intersection. We need this to get our final pixel.

The point of intersection is the solution that we came up for t plugged back into the vector:

The normal vector at the point of intersection is determined
from the formula below:

Let’s go through the algebraic use case for calculating the pixels in the view again

1) Calculate the coefficients A, B and C from the quadratic solution using the direction vector of the ray, the ray origin point, the center point of the sphere, and the radius of the sphere.

2) Use A, B, and C to calculate the point where the ray intersects with the sphere.

3) If the discriminant B² – 4C is less than 0, the ray does not intersect

4) If one of the roots of the solution t = -B ^+/- Sqrt ( B² – 4C)/2 has a root where t< 0, then we throw out the root.

5) We want all solutions where t >= 0 but is the smaller of the two roots.

6) Use t to calculate the intersection point

7) Use the intersection point to calculate the normal vectorOnce we determine if the ray intersects with the object, we need to determine the shading of the pixel based on the vector of a light source. The shading of the pixel is determined by the inner product of the light source vector with the normal vector ray intersecting the object plus any ambient light.

Now we have everything we need to create our ray-traced sphere in software. Below is the UML design of our ray tracing C# program divided into the core objects Shape, Vector, Light, LightIntensity, Color, Camera, View2D. The objects Sphere and Plane are objects for viewing that inherit from the Shape object and override the DoesRayIntersect method. Light and LightIntensity classes are used to determine the shading of the object based on the formula above. The View2D class is used to draw the pixel from the intersecting ray and the color determined from the Shading formula to the Form. The Camera class is used to determine each sample ray being passed to the algorithm. Most of the algorithm occurs in the overridden DoesRayIntersect method of the different shapes which not only determines if the ray sample intersects the object, but returns where it intersects if it does.

Click Here for Figure 2
UML Diagram of Ray Tracing Algorithm, reverse engineered using theWithClass UML Tool

The DoesRayIntersect method of the sphere used to determine the intersection of the ray with the sphere is shown below. This method is called in the Form’s Paint Event Handler for each pixel in the normalized camera grid to test and find the intersection of the ray from the camera to the sphere object and draws it if it exists. Note how DoesRayIntersect steps through each step of the algorithm and checks t along the way to make sure its a valid ray intersecting with the sphere.

After the intersection is determined and the normal vector is computed, we can combine the vector with the lighting vector to get a color for the vector. This is done with our LightIntensity object in the DetermineIntensity method shown below:

public void DetermineIntensity(Vector rayVector, ref Color aColor) // take the dot product of the light source vector and the vector we just determined // add the ambient value // use the red color for shading aColor.red = (lightSource.V * rayVector) + ambientLight; if (aColor.red < 0) aColor.red = -c.red; aColor.green = 0.0; aColor.blue = 0.0;}

We can also draw the 3D vector on a 2D surface using the x and y coordinates of the ray with the help of the DrawPixel method in the View2D class. We’ll use the resolution of the surface to scale the vector up so we can see it on the form. Also note that we add one to the position to make sure its not sitting in the negative plane of the form. A pen is created using the color we just came up with in our LightIntensity Object.

Drawing a Plane Although we didn’t talk about them in this article, the code also contains ray tracing for planes as well. If you want to examine ray tracing of planes, you can try uncommenting the code in the Form for creating a plane and comment out the code for drawing a sphere. The algorithm for drawing a plane is slightly different, although we derive t through the same algebraic method we did for the sphere. Some of the references below will give you a good idea on how a plane is ray-traced.

References on the Web This article was developed referencing the information from the following links: Ray Tracing by SigGraph
Ray Tracing: Graphics for the masses

ConclusionRay tracing is a very powerful demonstration of what a computer is capable of graphically purely through mathematics. With other techniques such as refraction and texture mapping you can produce some pretty awesome spectacles on your computer screen. Have fun tracing your steps in .NET!

The Complete Visual C# Programmer’s Guide covers most of the major components that make up C# and the .NET environment. The book is geared toward the intermediate programmer, but contains enough material to satisfy the advanced developer. The book starts by introducing the reader to the .NET environment and some basic C# program examples. The book then goes in depth on how to navigate the Visual Studio environment and introduces the reader to the C# language From here the book dives into the .NET framework and how to take advantage of its capabilities using C#. Some of the topics covered in great detail include ADO.NET database programming, ASP.NET and Web Services, COM interoperability programming, security in .NET, mobile phone programming, GDI+ graphic programming, multithreading, Windows Services, XML and SOAP in .NET, and much more. Chapters in the book contain programming examples, reference tables, and step-by-step tutorials to guide you through one of Microsoft’s greatest achievements in programming environments.

Mike Gold is President of Microgold Software Inc. and Creator of WithClass 2000 a UML Design Tool for C#. Visit http://www.microgold.com/. In the last few years Mike has consulted for companies such as Merrill Lynch and Chase Manhattan Bank in New York. He is been active in developing Visual C++ Applications for 10 years and looks forward to the possibilities in C#. You can reach him at techsupport@microgold.com.

Bitmap Images

The first type are called Bitmaps (or raster images) and are based on pixels. One of the disadvantages of this type of graphic is that it does not scale well. If you resize a bitmap image, you may notice that the image quality suffers. To understand why this happens, you need to realize what it means for an image to be composed of pixels. If you open a bitmap graphic in an application such as Photoshop and begin to zoom in on the image, you will probably notice that the image is broken down into smaller squares at around 300-400 percent. Keep zooming in and this will become more apparent. Each of these little blocks is a pixel and can contain only 1 color. Because a pixel takes up a visible amount of space and can only be filled with 1 color, you can imagine that some special process must be in effect to create the illusion of smooth transitions between colors. This is a dithering technique called Antialiasing that attempts to give the illusion of smooth blends between colors as well as to diminish the jagged effects of curves and diagonal lines. In the graphic below, the bitmap is antialiased. If it wasn’t, it would look even more jagged.

When scanning graphics into applications that deal with bitmap data only, make sure that you scan the image in at the exact size that you need. This will prevent you from having to resize the image and compromise the quality.

– bitmap

– vector

Vector Images

The other type of graphic is called a vector graphic. Vector graphics do not use pixels and are based on mathematical formulas that represent curves and lines. Vector graphics are very smooth looking and can easily be resized without loss of image quality. This is not a math tutorial so we will try not to go too in depth, however, the following example may clear up what makes vector graphics so sharp and scalable.

Let’s say that we draw a line that is represented by the equation 3x+2y-13=0. In order to double the size of that line, we would multiply the equation by 2 as follows 2(3x+2y-13=0). This should create a line that is 2x the size of the original and is based entirely on math and doesn’t use pixels which means that there is no need for the application to use a dithering effect to give the appearance that the line is perfectly smooth… It already is.

So what if you need to bring a vector based image into an application that does not support them? If the graphics application you are using cannot handle vector files then save them as EPS (Encapsulated PostScript) files. An EPS essentially places a PostScript wrapper around your image and preserves all of the image data. In the case of a vector image, the mathematical equations that represent your vector image will remain and not be converted when brought into the application.

MC MCSE is a popular computer certification website devoted to providing free learning materials to candidates pursuing Microsoft, CompTIA and Cisco certifications. To access these resources visit http://www.mcmcse.com

“I already know HTML. Does this mean it will be replaced by XML?”

There is a bit of confusion surrounding XML and it’s relationship with HTML. HTML already does its job quite well. If you were to use XML to create an easily understood general format for people to create web pages you would end up with something very similar (or identical) to HTML. The problem with HTML is that this is really all it can do. XML on the other hand, provides them ability to create other document formats such as databases, spreadsheets and e-commerce sites.

SVG could not be built on top of HTML because HTML’s format is fixed. XML on the other hand is the ideal candidate to create a new open graphics format for the web. If you would like to delve into XML in more detail, you can take a look at the following sites:

www.w3.org/XML/

“But am I going to have to learn XML in order to use SVG?”

The answer is no. You are going to have to learn SVG if you want to code it yourself. By doing that you will have learned this particular flavor of XML. XML used for a spreadsheet however, will probably look very different.

“What do I need to do to get started?”
It is expected that the major Browser’s will support SVG in the near future. Until they do release versions with native SVG support you will need to install an SVG viewer plugin for your current browser. There are several available. I tried Adobe’s viewer but there are others. These are the one’s that I am aware of:

Adobe: http://www.adobe.com/svg/viewer/install/
IBM : http://www.alphaworks.ibm.com/tech/svgview
CSIRO: http://sis.cmis.csiro.au/svg/index.html

“So how do I add SVG to my web site?”
You can create SVG in several different ways. The simplest and most straightforward way is to create a “.svg” file using a standard text editor. The format for an SVG file is similar to a HTML document but the tags are different.

<?xml version=”1.0″ standalone=”yes”?>
<!DOCTYPE svg PUBLIC “-//W3C//DTD SVG 20000802//EN” “http://www.w3.org/TR/2000/CR-SVG-20000802/DTD/svg-20000802.dtd”>
<svg width=”5cm” height=”6cm”>
<desc>An SVG example.</desc>
<rect style=”fill:blue;” x=”0.5cm” y=”0.5cm” width=”2cm” height=”1cm”/>
<rect style=”fill:green;” x=”3.5cm” y=”0.5cm” width=”1cm” height=”1.5cm”/>
<ellipse style=”fill:red;” cx=”2.5cm” cy=”3.5cm” rx=”2cm” ry=”1cm” />
<text style=”fill:black;” x=”0.8cm” y=”5.5cm”>A simple SVG example.</text>
</svg>

If you have your viewer installed correctly, you should be able to see this example posted at:

www.imswebtips.com/is58fig1.svg

The first two lines of the file identify this as an XML document to be interpreted as SVG. This is pretty standard boilerplate but it will need to be done correctly.

The interesting stuff starts within the SVG tags. As you will note the elements within this example are pretty simple to interpret. Rectangles, ellipses, text, images etc. Pretty much everything you could find within a HTML document.

Like DHTML, SVG also supports CSS (Cascading Style Sheets) and access to the DOM (Document Object Model) using Javascript. This means that an SVG document can be fully animated. But unlike DHTML, the document supports vector graphics so that it will be much faster and provide more flexibility.

Steve White of http://www.IMSWebTips.com Virtual Mechanics & IMSWebTips offers DHTML tools and information, and also publishes a web tips ezine with lots of great ideas, snippets of code, and HTML and DHTML tutorials for any webmaster, regardless of experience.