text:
Graphic Design/Sign Making

Signmaking and Graphic Design go as far back as man does. The first cave paintings were a form of Graphic Design as well as Sign Making because they conveyed a story as well as some form of directions to a place that was a viable hunting ground, for instance. They of course told others a story or many times were warnings to others of misfortune or good fortune,

Throughout the History Graphics/Sign Making made many evolutions of change.

Graphic design is present everywhere and often without us noticing it. From waking up to lying down, we come across thousands of visual stimuli created by various graphic disciplines.

The logo of the toothpaste, in the morning coffee, the poster of the film that has just opened, in the news of the day on TV or on the web, the lunch menu, the package of biscuits for lunch, the label on the socks, the image of the new store that opened.

Graphic design is present at all these moments, in combined forms and functions, through relevant and appealing messages, in which the goal is to communicate and stimulate positive reactions among consumers.

Let's present some examples of graphic design and sign making:

 * Posters
 * Flyers
 * Brochures
 * Mupis
 * Infographics
 * Business Cards
 * Layout of a website or mobile application
 * Book covers
 * Logos
 * Product labels
 * Product packaging

What is Graphic Design?
According to the American Institute of Graphic Arts (AIGA), graphic design is defined as "the art and practice of planning and designing ideas and experiences with visual and textual content.

In other words, graphic design communicates ideas or conveys messages through visual aids. These visual aids can be a logo, a website, or an event.

Graphic design is an essential tool for companies to promote and sell products or services through advertising, to share relevant information on their websites, or to develop an identity through branding, among others.

It is also important to mention that although the concept of graphic design is very associated with commercial purposes, such as ads, visual identities of brands, in reality, this tool is also widely used in other contexts, including as a form of artistic expression.

To better understand this concept, we also consider it relevant to present some of the main elements that compose it, are they:

 * Lines
 * Colors
 * Spaces
 * Shapes
 * Textures
 * Sizes
 * Among others

Lines: Straight, curved, wavy, thick, thin - when it comes to lines, the possibilities are limitless. Lines allow designers to divide a space or separate content in a layout. They can also be used to guide the eyes of the viewer, or make other elements follow a strategic path for added findability, to get the viewer easily from point A to point B.

Shapes: Shapes offer a variety of ways to fill spaces creatively, to support text and other forms of content, and to balance a design. Shapes can be created out of nothing, using white space to give a design structure and clarity.

Colour: Colour, or the absence of colour, is an important element of any design. With a solid understanding of colour theory, designers can amazingly influence a design and a brand, seamlessly integrating colour boldly or with brilliant subtlety.

Type: Type can transform a message from mere text to a work of art. Different fonts, combined with customized alignments, spacing, size, and colour, can add power to the point you are communicating to the world.

Texture: Even a smooth and glossy advertisement can seem tangible with texture. It gives a sense of a tactile surface through its visual appearance and adds a sense of depth, enhanced by selection of appropriate paper and material.

In addition to these elements are the principles of graphic design:

 * Movement
 * Balance
 * Standard
 * Repetition
 * Rhythm
 * Proportion
 * Variety
 * Unit

It's the combination of the elements and principles of graphic design that allows professionals to create vibrant and impactful compositions that stay in the memory of consumers!

As we have shown throughout the article, the concept of graphic design is vast and encompasses different aspects and specializations. There are several types of graphic design, we highlight just a few:

 * Web design
 * Animation
 * Motion Graphics
 * Print design

Web Design is one of the areas that develops with the arrival of technology and that gains more and more prominence. In fact, it is essential for those who use the web as a work tool or for research, for leisure or other activity, to be able to find the information they need on websites.

This is one of the great functions of professionals, design intuitive and accessible websites for their users and this is also a job that requires knowledge of graphic design.

When we talk about Animation we mean special effects for TV programs, cartoons, movies or video games, for example.

Motion Graphics is related to sounds, videos or graphics. These are some examples of print design, flyers, posters, brochures or other printed media.

Graphic design becomes increasingly important as companies and consumers begin to use different communication channels to promote and advertise their products or services. Knowing how to create visually appealing images can increase awareness and boost your business.

Tools of Graphic Design
Professional designers possess a creative mind with an artistic inclination, and so much more. Keen observation skills and analytical thinking are essential tools for graphic design, before they dig into their physical tool kit and touch pen to paper or stylus to tablet. Designers employ a variety of methods to combine art and technology to communicate a particular message and create an impressive visual.

Sketchpads: A traditional tool used to sketch out ideas; it is the quickest way to jot down the rough designs, which designers can develop further using other tools and technologies.

Computers: Computers now occupy an essential place in every designer's tool kit. Hardware such as tablets allow designers to expand their creative freedom and maintain that sketchpad feel.

Software: Technology has opened new doors for realizing creative vision. Specialized software such as Illustrator and Photoshop can help to create illustrations, enhance photographs, stylize text, and synergize all of the pieces in incredible layouts.

Graphic Design communicates your brand and message visually with impressive business logos, enchanting brochures, newsletters with impact, and stunning posters.

title: Graphic Design/Sign Making


text:
Wikijunior:How Things Work/Fluorescent Lamp

Fluorescent lamps make light from hydrogen and phosphor.

Who invented it?
Many people did, including Thomas Edison, Georges Claude and Heinrich Geissler.

How does it get power?
When you plug the cord into a wall, it uses electrical current. When the current gets faster, it heats up, giving it a glow.

How does it work?
A fluorescent lamp consists of a tube containing a gas, Mercury, and special coating on the inside surface, Phosphor. A coil inside the tube is heated and emits electrons which collide with the atoms of Mercury inside the tube. The gas produces invisible ultraviolet rays which, when they meet the phosphor, which coats the tube, turns into visible light, which we see.

How dangerous is it?
Mercury is very poisonous and can kill. The lamp should not be used if damaged as it may leak mercury fumes. Instead if should be carefully disposed of. Often local authorities have special instructions for the disposal of fluorescent lamps to make sure the mercury does not spread into the environment or nearby water sourses.

What does it do?
They are a type of light and are used to make it easier to see in dark places. Light is produced when the phosphor lights up.

How has it changed the world?
Fluorescent Lamps use less electricity than traditional light bulbs, because they produce less heat. Incandescent light bulbs use a significant proportion of the energy producing heat, which is not very useful. Therefore, more energy is needed to make the same amount of light, because much is wasted.

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Horticulture/Bidens frondosa

Devil's beggartick (Bidens frondosa) is an annual herb in the family Asteraceae, native to North America.

This plant is known by a variety of different names, including Bur Marigold, Devil's Bootjack, Devil's pitchfork, Pitchfork Weed, and Sticktight.

The sticky seeds make this plant a nuisance for pet and livestock owners, and it is generally seen as a weed.

Description
It looks similar to a Dahlia plant, up to 2 m tall, usually with reddish stems. Its flowers are yellow, produced in early autumn, followed by numerous seeds with hooked barbs that attach onto passing animals' fur or clothing or sometimes even skin which allow the seeds to be dispersed widely.

Uses
During flowering, the plant is an autumn nectar source, though other plants should be used instead because of the seed problems.

title: Horticulture/Bidens frondosa


text:
Talk:Horticulture/Bidens frondosa

Transwiki notes
Transwikied from wikipedia (Bidens frondosa) 10:12, 16 September 2006 (UTC) using this version. SB_Johnny | talk 10:12, 16 September 2006 (UTC)

title: Talk:Horticulture/Bidens frondosa


text:
Horticulture/Agrimonia

Agrimony (Agrimonia) is a genus of 12–15 species of perennial plants in the family Rosaceae, native to the temperate regions of the Northern Hemisphere, with one species also in Africa.

Description
The species grow to between 0.5 and 2 m tall, with pinnate leaves, and yellow flowers borne on a single (usually unbranched) spike. The bur-like seeds are very sticky, persisting through the winter.

Species

 * ../Agrimonia eupatoria/ - Common Agrimony (Europe, Asia, Africa)
 * ../Agrimonia gryposepala/ - Tall Hairy Agrimony (North America)
 * ../Agrimonia incisa/ - Incised Agrimony (North America)
 * ../Agrimonia koreana/ - Korean Agrimony (eastern Asia)
 * ../Agrimonia microcarpa/ - Smallfruit Agrimony (North America)
 * ../Agrimonia nipponica/ - Japanese Agrimony (eastern Asia)
 * ../Agrimonia parviflora/ - Harvestlice Agrimony (North America)
 * ../Agrimonia pilosa/ - Hairy Agrimony (eastern Europe, Asia)
 * ../Agrimonia procera/ - Fragrant Agrimony (Europe)
 * ../Agrimonia pubescens/ - Soft Agrimony (North America)
 * ../Agrimonia repens/ - Short Agrimony (southwest Asia)
 * ../Agrimonia rostellata/ - Beaked Agrimony (North America)
 * ../Agrimonia striata/ - Roadside Agrimony (North America)

Uses
Historically, the plants were thought to have medicinal value.

In wicca (witchcraft) it is used to help create a deep, undisturbed sleep by slipping dried leaves inside the sleeper's pillow.

Agrimonia was first described in writing by the Greeks who used it to treat conjunctivitis, other eye ailments, wounds (especially on the battle field), and liver ailments. Agrimonia is Latin, a variant of argemonia, and comes from the Greek word agermone which translates to, "speck in the eye." Eupatoria, as in agrimonia eupatoria, is derived from the name of King Mithridates IV Eupator (132 BC – 63 BC), ruler of Pontus in northern Turkey. He is well known in history for his knowledge of plant lore as well as the Mithridates Wars which he led against the Romans. Agrimonia has been used since ancient times in Egypt to treat the digestive system and in Eastern Asia it is still used to treat heavy bleeding, coughs and flu.

The Anglo Saxons knew agrimonia as "garclive", and used it for wounds, warts, snake bites and, as did the Romans, eye ailments and liver disease. English poet Michael Drayton (1563–1631) declared agrimony to be an "all heal" herb. In France and later throughout Europe it was an active ingredient in arquebusade water, which was used to treat wounds inflicted by an arquebus, a small gun operated by a matchlock mechanism dating to the 15th century.

Recent studies published by The U.S. National Institute of Health (NIH) and other scientific institutions suggest that chemicals in the plant may stimulate cytokines, which are proteins that stimulate the immune system.

Maintenance
Very low maintenance, transplants easily.

Propagation
By division or seed.

Control
Control may be needed if growing where pets play, as the seeds of some species are very difficult to remove from fur and clothing.

title: Horticulture/Agrimonia


text:
Talk:Horticulture/Agrimonia

Transwiki notes
Copied from Argimony 10:37, 16 September 2006 (UTC) using this version SB_Johnny  | talk 10:37, 16 September 2006 (UTC)

title: Talk:Horticulture/Agrimonia


text:
World Stamp Catalogue/Faroe Islands

1975

1997
 |Faroe Islands

title: World Stamp Catalogue/Faroe Islands


text:
Template talk:Wikipediapar

See Template talk:Wikipedia for a discussion of both this "Wikipediapar" template and the very similar "Wikipedia" template. --DavidCary 11:50, 16 September 2006 (UTC)

title: Template talk:Wikipediapar


text:
Template:Hortibox/Examples

This template sets up an infobox for a plant's growing requirements. Although it might look complicated, it is relatively simple to use. Most parameters are optional, so if a particular entry is not relevant for the plant in question (or you just don't have the information), just leave it out.

This is a generalized template for garden plants. There are more specific templates available for certain types of plants; see Horticulture/Using Templates.

Using Template:Hortibox
This template is automatically included by and.

Example
/Templates/Examples

title: Template:Hortibox/Examples


text:
World Stamp Catalogue/Faroe Islands/1975

January 30th. 1975
1975


text:
Basic Physics of Nuclear Medicine/PACS and Advanced Image Processing

Picture Archival & Communication Systems (PACS)
With the phenomenal development of computer technology in recent times has come the possibility of storing and communicating medical images in digital format. PACS systems are generally based on a dedicated computer which can access data stored in the digital image processors of different imaging modalities and transfer this data at high speeds to remote viewing consoles, to archival storage media and to other computer systems either within the hospital or at external locations – see the figure below:

Successful implementation of PACS is critically dependent on several factors which include image format standardization, HIS and RIS integration, image display devices, image transfer rates and storage capacity. These features are discussed below.

Standardization of the manner in which the image data is interchanged between different medical imaging devices. The Digital Imaging & Communications in Medicine (DICOM) standard has been embraced by most equipment manufacturers to facilitate this. Another file format which has been developed specifically for nuclear medicine images is called Interfile. Besides specifying the format of digital image data, these information interchange formats also cover patient and examination details which are embedded within the image file. This latter feature is particularly important in medical imaging so that patient studies do not get mixed up, for example, and can be regarded as generating a birth certificate for each acquired image, or set of images. An example of such DICOM header information is shown in the following four figures (the header, which is typically one continuous document, has been broken into four parts here to assist with our discussion):

Notice that the data provide patient details as well as the image type, the date and time of the study, the modality, the scanner manufacturer and image processing workstation used. The second part of this header is shown below:

Notice that this data covers the slice thickness and spacing used in this SPECT study, image sampling and quantization information, the number of images and the photon energy window used by the scanner. The third part of this header is shown next:

Notice that this data covers details of the scanner movement used to acquire the study. The fourth and final part of this header is shown below:

Notice that this final part details the patient and scanner orientation as well as the actual image data.

Other image formats are in common use in medicine, for purposes other than primary diagnosis. These formats can be useful for teaching, multimedia and publication purposes. Examples of these formats are included in the following table.

The Joint Photographic Expert Group (JPEG) format is widely used for image transfer using the World Wide Web because the image data can be reduced in size using image compression techniques and hence can be transferred relatively quickly. The compression technique used by this format typically results in the loss of image data which cannot be exactly recovered. Hence the reference to Lossy compression in the Table. The format, as you might appreciate, is not used for primary diagnosis but is nevertheless useful for teaching and related applications.

The Portable Network Graphics (PNG) format is the most recent of these formats and has advantages in terms of Lossless compression, platform independent image display and compression features and the ability to embed patient and study identification information.

The Tagged Image File Format (TIFF) is widely used in the publication industry and provides the capability for both lossless and lossy compression. Its lossless compression however results in large image file sizes.

Finally the Graphics Interchange Format (GIF) is widely used for transferring graphical images (e.g. graphs, diagrams, flowcharts etc.) via the World Wide Web, and can also be used for animated graphics.

High quality display devices are generally needed for medical images. Cathode ray tube (CRT) and liquid crystal display (LCD) monitors are widely used with their visual characteristics matched to the display task. Monitors for digital mammograms and chest radiographs, for instance, require a relatively high luminance and spatial resolution, while those used for nuclear medicine and ultrasound images don't have such stringent specifications but do require colour and dynamic imaging functionality – and those used for CT and MRI are the same, except maybe for colour processing, but also require a high contrast resolution. In addition, monitors used for clinical review generally have lower spatial resolution requirements than those used for primary diagnosis.

The CRT technology has disadvantages which include a nonuniform luminance and a high veiling glare. The luminance of a CRT monitor is generally highest in the centre and falls off, as does its spatial resolution, towards the periphery of the screen. Veiling glare results from light reflections inside the tube and can have a substantial negative influence on both spatial resolution and contrast. LCD monitors, on the other hand, are characterized by increased luminance, luminance uniformity, spatial resolution and contrast, as well as a lower electrical power consumption and desktop footprint. Visualization of displayed images is affected however when the viewer is not directly in front of the screen, because of optical polarization effects, but this is about the only disadvantage relative to CRTs.

Luminance is an important feature because of its negative affect on diagnostic accuracy and a number of medical display standards therefore specify minimum values, e.g. the American College of Radiology specifies a minimum of 160 cd/m2. Viewboxes, which have been used traditionally in medical imaging, have a considerably higher luminance than computer display devices, whether they be CRTs or LCDs. Luminance values for various display devices are compared in the following table:

Notice in the table that viewboxes have a luminance five times or more greater than LCD monitors. As a result, windowing techniques are widely used to compensate. Notice also in the table that greyscale monitors tend to have a higher luminance than their colour counterparts.

In addition, the image display workstation interface must be user-friendly. That is, interfaces which control the display, manipulation, analysis, storage and distribution of images need to be intuitive, efficient and specific within a medical context.

Further, the efficient distribution of images throughout large hospital campuses and associated clinics has been enhanced by the availability of free web browsing software and has meant that distribution of images can be achieved at a fraction of what the cost was prior to their introduction.

Image transfer times should be short in any PACS system for obvious reasons. Ideally an image should appear on the monitor within 2 seconds of the request for the image. The increasing availability of high speed networks are allowing this requirement to be met more readily. A comparison of transfer speeds for a number of common network connections are shown in the following table.

Finally, PACS environments should have access to relatively cheap archival storage up to a few Tbytes (i.e. a few million Mbytes) of image data and must provide retrieval of non-current image files in a reasonable time – say, less than a minute or two. Current solutions include robotic digital tape archives and optical disk Juke Boxes.

The Internet & The World Wide Web
The Internet is a global assemblage of computer networks and an explosion in its use has occurred in recent years. Its origins can be traced to activities associated with connecting US university, military and research networks about 30 years ago by the Advanced Research Projects Agency and the Inter-Networking Working Group, to the US National Science Foundation network in 1986, through the release of public-domain software by groups at the European Organization for Nuclear Research (CERN) in 1991 and at the University of Illinois National Center for Supercomputing Applications (NCSA) in 1993 to the recent generation of substantial global interest.

The system facilitates the transfer of data, computer programs and electronic mail and allows for discussion of specialised topics among newsgroups as well as other features such as telnet, internet relay chat and file sharing. Irrespective of the application however, the system essentially allows for the convenient exchange of information between computers on a global basis. This section gives a very brief overview of the Internet from a general perspective of electronic communication protocols and the World Wide Web.

All forms of communication, be they based on electronic or other means, are reliant on some form of protocol. A common protocol when someone answers a telephone, for instance, is to say hello, to give a greeting or to announce the location/telephone number of the receiver. Communication between computers connected to the Internet uses a protocol called the Transmission Control Protocol/Internet Protocol (TCP/IP). This approach is an amalgam of two protocols, the details of which are of no great relevance to our discussion here, other than to note that they together provide an electronic communication protocol which allows two computers to connect via the Internet. One feature of TCP/IP to note however is that it can be used to communicate between different types of computers, i.e. it is platform independent. An IBM-compatible personal computer can therefore communicate with, for example, an Apple computer or a UNIX workstation. Related protocols which are used when computers communicate over a telephone line are the Serial Line Internet Protocol (SLIP) and the Point-to-Point Protocol (PPP). Once communication has been established between two computers, an additional protocol is needed to exchange computer files. A common protocol used for this purpose is called the File Transfer Protocol (FTP). The types of files which can be transferred are typically computer programs as well as data such as word processed documents, spreadsheets, database files and images.

A refinement to FTP is the Hypertext Transfer Protocol (HTTP) which allows the transfer of documents which contain data in the form of different media-types, and is widely used for webpage display. Examples of media-types are text, images and sound. Finally, two protocols relevant to electronic mail are the Post Office Protocol (POP) and the Simple Mail Transfer Protocol (SMTP), and a protocol in use for newsgroups is the Network News Transfer Protocol (NNTP).

The World Wide Web (WWW) is a conceptual interpretation of the Internet when it is used to transfer documents using the HTTP. These documents are generally called web pages and are written using an editing language called Hypertext Markup Language (HTML). This format provides control over, for instance, the size and colour of text, the use of tables and, possibly most importantly, the facility to link the document to documents which exist elsewhere on the WWW. HTML also allows the insertion of various media-types into documents. Images can be inserted, for instance, in formats such as the Graphical Interchange Format (GIF), the Joint Photographical Experts Group (JPEG) format or the Portable Network Graphics (PNG) format, as discussed earlier, and image sequences can be displayed using one of the Moving Picture Experts Group (MPEG) formats. This latter functionality is useful for instance, for display of dynamic nuclear medicine studies.

The transfer of HTML documents is illustrated in the following figure. The user's computer (referred to as the client) is equipped with software (called a web browser) which allows it to interpret HTML documents and to communicate via the Internet using TCP/IP. The computer is also equipped with hardware which allows it to physically connect to the Internet, for example:
 * an ADSL modem for connecting via a telephone line to an Internet Service Provider, and
 * Local Area Network (LAN) hardware for connecting via an institutional network, such as an Ethernet connection.

At the other end of the connection is a computer containing a document or set of documents of interest to the user. This second computer is called a server and contains the documents in HTML format. An example of a software package which is used within the server computer is Apache. The sequence of events is typically as follows:

 * The user establishes contact between the client and server computers by directing the browser at the Uniform Resource Location (URL) of the server and requests a given HTML document. The direction is typically of the form:

http: //www.server.type.code/doc.html where:

 * The server receives the request, gets the requested document from its storage device and sends the document using HTTP to the client.

 * The client receives the document and the browser interprets the HTML so that text, links and media-types are presented appropriately on the display device.

Many WWW browsers also provide the ability for the user to download files using the file transfer protocol (FTP), to send and receive e-mail messages and to contribute to newsgroups. For example, the process for downloading files using FTP is similar to that illustrated in the last figure except that the user directs the browser at a URL of the form:

ftp: //ftp.server.type.code/doc.xxx

Sophisticated WWW browsers, such as Netscape Navigator and Internet Explorer, also provide the ability to generate more than basic web-pages at the client's computer. One implementation is the ability to interpret client-side scripts. These are small programmes which are downloaded as part of the HTML document and are executed using the client computer's resources. By this means, for instance, the script can read the date and time from the client computer or use its arithmetic functions to make calculations, and embed this information in downloaded webpages. Client-side scripts can be written using languages such as JavaScript.

Another implementation is the ability to execute small applications (called applets) which are downloaded with the HTML document and run on the client computer. Such applets can be generated using languages such as Java (not to be confused with JavaScript!). Applets are well developed for graphics applications, such as animations and scrolling banners. One exciting development in this field is the ability to download image processing software along with an image, so that the user can manipulate the image without the need for a special image processing program.

Finally, a refinement to HTTP server software allows interaction from the client so that information can be returned to the server for executing specific tasks, such as searching a database, entering information into a database or automatically correcting and giving feedback on multiple choice exam questions. Additional software is required for this server-side processing – a common form of which uses the Common Gateway Interface (CGI) protocol. Small CGI programs are generally referred to as scripts and are written in a language such as Perl.

Online databases can also be accommodated within the client/server model. For example, mySql is a package which has been widely adopted for this purpose. Scripts for administering this server software can be written in languages such as PHP.

As might be anticipated, the field of electronic communication introduces a vast range of additional concepts to those discussed above – and, like PACS, are just as unrelated to medical concepts! However, further treatment of the subject is beyond our scope here since our interest is confined in the main to the distribution of medical images.

Spatial Registration of Images
Correlative imaging is widely used in medical diagnosis so that information gleaned from a number of imaging modalities can be merged to form a bigger picture about a patient's condition. However, the actual merging of image data on a routine basis in hospitals and clinics has had to await the development of relatively cheap and powerful computers and such image fusion is now commonplace. It is generally necessary to spatially align image data prior to the fusion process so as to address differences in orientation, magnification and other acquisition factors. This alignment process is generally referred to as image registration.

Suppose we have two images to be registered – a planar nuclear medicine scan and a radiograph, for instance:

The registration process generally assumes that a correspondence exists between spatial locations in the two images so that a co-ordinate transfer function (CTF) can be established which can be used to map locations in one image to those of the other. In the above example, as in many clinical situations, a number of compatibility issues need to be addressed first. The obvious one arises from the different protocols used for image acquisitions, i.e. a palmar view in the bone scan and a posterior-anterior projection radiograph. We can handle this issue in our example case by extracting the right hand data from the bone scan and then flipping it around the horizontal axis. A related issue arises when different digital resolutions are used – in this case, the nuclear medicine image was acquired using a 256 x 256 x 8-bit resolution, while the radiograph was acquired using a 2920 x 2920 pixel matrix with a 12-bit contrast resolution. Since we may be interested in maintaining the fine spatial resolution of the radiograph, we can magnify the bone scan to the radiographic resolution using an interpolated zoom process. The outcome of these steps is illustrated below:

When we assume minimal spatial distortion and identical positioning in the projection radiograph, we can infer a spatially uniform CTF, i.e. the transform applied to one pixel can also be applied to each and every other pixel. Let's call the two images to be registered A and B, with image A being the one to be processed geometrically to correspond as exactly as possible with image B. The CTF can then be represented by the following equations:

u = f(x,y)

and

v = g(x,y)

where:
 * f and g define the transform in the horizontal and vertical image dimensions;
 * ( u,w ) are the spatial co-ordinates in image A ; and
 * ( x,y ) those in image B.

The first computing step is to generate an initially empty image C in the co-ordinate frame ( x,y ) and fill it with pixel values derived from applying the CTF to image A. The resultant image we can say is a version of image A registered to image B.

The question, of course, is how to determine the CTF. For situations where simple geometric translations and rotations in the x- and y-dimensions are required, the functions f and g can involve relatively straight-forward bilinear interpolations. Such transformations can also compensate for image magnification effects, and the resultant processes are referred to as rigid transforms. When spatial non-uniformities are encountered, non-rigid transforms can be used to apply different magnification factors in both x- and y-dimensions, as well as other geometric translations – in which case higher order interpolants can be applied.

Determination of the parameters of the CTF is obviously needed and there are numerous methods we can use, for example:
 * Landmarks – where corresponding locations of prominent anatomical features in both images can be identified and two sets of co-ordinates can be derived on this basis to define the CTF. Note that artificial landmarks can be created using external markers during image acquisition, where, for instance, a set of markers which are both radioactive and NMR sensitive can be fixed to the surface of the patient during image acquisition for subsequent registration of SPECT and MRI scans.
 * Function Minimization/Maximization – where an indicator of the quality of registration is monitored as various geometric transformations are applied to the image in an iterative fashion to search for a set of parameters which minimize (or maximise) this indicator. When both images are SPECT scans, acquired some months apart for instance, a quality measure such as the sum of the absolute pixel value differences can be applied. A more complex quality measure is typically required when the two images are from different modalities. We will concentrate our discussion below on this latter scenario.

The concept of the joint histogram is important in this regard. Individual statistical histograms for our two images are shown below:

The bone scan's histogram indicates that a substantial proportion of the image is composed of dark pixels, with a much smaller number of brighter pixels arising from the hot spot. The histogram for the radiograph indicates that the image is composed of a substantial number of bright pixels with a broad spread of grey shades. Note that the term frequency used in this context refers to the frequency of occurrence of pixel values, i.e. the number of times individual pixel values occur in an image, and not to the terms temporal frequency and spatial frequency which we've encountered elsewhere in this wikibook.

The joint histogram is a related concept to the individual image histograms where the pixel values for pairs of pixels in the two images are plotted against each other on the one graph. In other words, the value of a pixel in one image is plotted against the value for the same pixel location in the second image. A good way to introduce this concept is by first of all comparing an image with a duplicate of itself, and then with shifted versions of this duplicated image, as illustrated in the following figure. We can use colour processing to assist in our visual comparisons, where the bone scan (the reference image) can be displayed using a red CLUT, for instance, and its shifted version using a green CLUT. As a result, where the two images overlay each other, the layered image data is displayed in shades of yellow, i.e. red plus green on the colour spectrum, in overlapping regions.

The top row in our figure shows the situation when the two images are in perfect alignment. Note the resultant yellow-only colour scale. The joint histogram for this case consists of a diagonal straight line because the values of all pixel pairs in the two images are identical. The next row of our figure illustrates the effect of a horizontal shift of eight pixels between the two images. Notice that regions of mismatch are seen in shades of red and shades of green, as the case may be, and overlapping regions in shades of yellow. The joint histogram now has the appearance of a scatter plot because pixel values in the two images no longer correspond spatially. A bright pixel value in one image might now overlay with a dark region of the other, for instance, and vice-versa.

The third row in our figure illustrates the effect of a rotation of 15 degrees and the bottom row shows the combined effect of shifting and rotation. The basic lesson to learn from this is that perfect alignment between two identical images is indicated by a straight diagonal line in the joint histogram and lack of alignment results in a form of scatter plot. The major lesson to learn is that when two images are out of alignment, statistical techniques can be applied which endeavour to minimize the scatter in the joint histogram – and hence effect a spatial registration of the two images.

The situation is a bit more complicated when the two images to be registered are acquired using different imaging modalities, e.g. a nuclear medicine scan and a radiograph, because their individual histograms are likely to be substantially different from each other – as we've seen in our earlier figure. Nevertheless, methods to minimize the scatter plot in the resultant joint histogram can be used to register the two images, as illustrated in the following figure:

Compatibility issues between the two images for this registration process were addressed by first converting the radiograph from 2920 x 2920 x 12-bit resolution to 256 x 256 x 8-bits. The top row of the figure illustrates the situation and the joint histogram shows significant scattering in this data, as might be expected. The bottom row illustrates the outcome of a Mutual Information (MI) maximization process where a solution was found that involved shifting, rotating and magnifying the bone scan. While the joint histogram still depicts substantial scattering, the MI index can be seen to increase from 0.17 in the non-registered situation to 0.63 following registration, and the overlay image depicts the lesion in the bone scan registered to (or colocalized with, as is sometimes said) the radiograph.

This type of image registration can ideally be generated automatically using a computer. An iterative process is generally followed, where the MI indicator is maximized initially for low resolution versions of the two images and then progressively for increasingly higher resolutions. Note however that reducing the resolution of the radiograph can substantially effect its spatial quality and that, while registration may be effected at this lower resolution, the resultant CTF can be used with appropriate magnification to register the bone scan with the full resolution radiograph – as illustrated below:

Other image similarity measures besides Mutual Information can also be applied depending on the nature of the data in the two images. These include:

 * Count Difference Minimization: where the sum of the absolute count differences between all pixels is minimized.
 * Shape Difference Minimization: where segmentation techniques are used to define the borders of the object to be registered in the two images and a similarity measure based on the distance between these borders is minimized.
 * Sign Change Maximization: which maximizes the number of positive/negative sign changes following subtraction of shifted versions of one image relative to the reference image.
 * Image Variance Minimization: which minimizes the statistical variance between two images.
 * Square Root Minimization: which minimizes the square root of the absolute count differences between all pixels in the two images.
 * Gradient Matching: which is based on comparing edges in the two images.

The technique chosen for an individual pair of images is primarily dependent on the nature of the image data. Some techniques may be readily applied to intra-patient, intra-modality studies where, for instance, bone scans of the same region of the same patient acquired some time apart are compared – in a follow-up study for example. Other techniques may be required for inter-modality comparisons, e.g. a nuclear medicine and an MRI scan, while others still for inter-patient, intra-modality comparisons – where a patient's images are compared with those in an atlas of normal and diseased conditions, for instance.

Finally, its of relevance to note that while spatial registration techniques were introduced here using 2D images, the approach can also be readily extended to the 3D case through comparisons of statistical features in voxel data, e.g. registering SPECT and CT scans, or PET and MRI scans, for example. Here registration of individual slices can be applied sequentially through the volume of interest.

Image Segmentation
Many forms of image analysis require the identification of structures and objects within an image. Image segmentation is the process of partitioning an image into distinct regions by grouping together pixels which belong to the same object. Two general approaches have been developed:

 * Threshold Definition: where some property of an image is compared to a fixed or variable threshold on a pixel-by-pixel basis. A simple example is a grey-level threshold where a look-up table (LUT) of the form illustrated in the left hand panel of the figure below is applied, and where the value of the threshold, T, can be adjusted interactively.

 * This is a useful technique when the image contains a single, well-defined object or group of objects of similar pixel value superimposed on a background with a substantially different pixel value. However, difficulties can arise with grey-level thresholding when objects are close together, e.g. cardiac chambers. Histogram analysis can be used as an alternative where pixel values are thresholded on the basis of their frequency of occurrence, as illustrated in the right hand panel of the figure above.  Other alternatives include thresholding colours when a CLUT is applied, monitoring the time of arrival of a tracer or contrast medium in a region of an image and analysis of the variation in pixel values in the neighbourhood of a pixel within an object of interest.

 * Region Growth: which exploits two characteristics of imaged objects:
 * pixels for an object tend to have similar pixel values, and
 * pixels for the same object are contiguous.
 * A common technique is based on firstly defining a starting pixel in the object and then testing neighbouring pixels on the basis of a specific criterion for addition to a growing region. This criterion could be based on pixel value considerations, as in the following figure for instance, or on the anticipated size or shape of the object.

 * Note that this approach can be extended to grow regions in three-dimensions when the image data consists of a set of contiguous tomographic slices.

Image Fusion
A method of combining image data to form a fusion display is required once images have been registered. A simple approach is to add the two images. Multiplying them is also an option. However, this form of image fusion tends to obscure the underlying anatomy when hot spots exist in the nuclear medicine data, as illustrated in the following figure:

A second approach is to interlace the two images so that a fusion display is built up using alternate pixels, alternate pixel groups or alternate lines of data from each image, as illustrated in the following figure:

However, such interlacing can highlight features associated with the interlacing process itself, as illustrated by the vertical lines in the left panel of the figure above. The so-called checkerboard display, as illustrated in the right panel above, is a related technique where alternate groups of pixels are displayed in a tiled fashion.

A third approach is to use an image compositing technique called Alpha Blending, which uses a transparency value, α, to determine a proportional mixing of the two images, as illustrated in the following figure:

This type of approach is highly developed in the publishing industry and a wide range of fusion options are available. A common one, which was used for the images above, is to apply an equation of the form:

Fused Image = (α) Image1 + (1-α) Image2.

A transparency value of 0.5 was used to generate the image in the left panel above, for instance, with the result that the underlying anatomy can be discerned through the hot spot. A powerful feature of this approach is that the fusion transparency can be varied interactively so as to optimize the data presentation, for instance, or to confirm the quality of the registration process (as illustrated in the right hand panel above).

This blending approach can be extended to incorporate a variable opacity function, where different transparency values are applied to different parts of the grey scale of one image. Note that the terms transparency and opacity have a reciprocal relationship in this context. Example blends are shown in the following figure:

The High-Low-High opacity function, for instance, applies a high level of opacity to pixel values at the top and bottom ends of the contrast scale of one of the images and a low opacity to intermediate pixel values. The result is improved visualization of fused data outside of hot spot regions – as illustrated in the top right panel above. The Low-High-Low function has the opposite effect and generates the capability to visualize the relevant anatomical detail with a highlighted region around it – as shown in the bottom left panel above. Logarithmic, exponential and other opacity functions can also be applied, depending on the nature of the two images to be fused.

The choice of opacity function and CLUT for use in image fusion applications would appear to be an artistic, in contrast to a scientific or infotech, endeavour in that the final result is often achieved using aethestic impressions which convey the medical information of relevance. Each study can require a reasonably unique combination of image processing steps depending upon whether hot or cold spots exist in the nuclear medicine study and upon the nature of the image data in the anatomical study, be it from radiography, X-ray CT, sonography or from one of the various forms of magnetic resonance imaging. It is for this reason that computers used for this type of application tend to feature highly intuitive and tacit user interfaces with powerful visualization capabilities. OsiriX, for example, runs only on the Macintosh platform for this reason. A second example is provided by a major medical equipment manufacturer which gave the name Leonardo to a product line!

A final method of image fusion that we'll mention briefly is referred to as Selective Integration, where segmentation techniques, for instance, can be used to extract structures from one image so that they can be pasted to relevant regions of a second, spatially-registered image.

We'll conclude this chapter with an example illustrating the 3D alignment and misalignment of the fused study shown in the following image:


text:
Flute/Fingering Chart

Fingering chart
Fingering charts use symbols to communicate which keys should be pressed in order to play the desired note. The blackened keys should be closed, while the white keys should be left open.

To learn more, watch this video on how to use a fingering chart.

Now that you know how to use a fingering chart, here are two quality charts:
 * 1) wfg.woodwind.org - fingering chart for your desktop computer
 * 2) fingercharts.com - fingering chart for your phone or tablet

For a printable chart, you can use the one below.

title: Flute/Fingering Chart


text:
OpenGL Programming/GLStart/Tut4

Tutorial 4: Translation, Rotation, and Scaling
This tutorial will teach you how to manipulate objects in 3D space. Since we haven’t covered 3D drawing yet, we will manipulate the 2D primitives we created in the previous tutorial.

The Projection and Model Transformations
If you remember from the second tutorial, we created a function called Resize that handles the resizing of the window. I'm not sure if the code within that function was explained well, so lets go over it again. Here is the whole code from the function Resize:

void Resize(int width, int height) {         //set viewport glViewport(0,0,(GLsizei)width,(GLsizei)height); glMatrixMode(GL_PROJECTION);//change matrix mode to projection glLoadIdentity;//load identity matrix //set perspective gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,1.0f,1000.0f); glMatrixMode(GL_MODELVIEW);//change matrix mode to modelview glLoadIdentity;//load identity matrix }

The first line, the glViewport function, determines what amount of the window that OpenGL draws on. We set it here to the whole window.

The interesting thing here to note is the glMatrixMode function. This function takes as one parameter the matrix we want to edit. I am going to save the discussion of matrices for a while (perhaps for a different tutorial or a simple article). But basically the first call to glMatrixMode with the parameter GL_PROJECTION affects how the user views the OpenGL scene. So in the line after that I put in glLoadIdentity to set the Projection matrix to the identity matrix. Then in the next line I used the gluPerspective function, which allows for a realistic view of a scene, since an object close to the viewer is large and the same object far from the viewer is small. The parameters for gluPerspective was the angle of the view, the aspect ratio (width to height), the nearest z position the viewer can see and the farthest z position the viewer can see.

After that line, I changed the matrix mode again to GL_MODELVIEW, which affects what is called the Model View matrix. When editing the Model View matrix, you are only affecting the objects in the scene, not the actual camera that is pointed at the 3D scene. So any changes you make to the Model View matrix will affect just the objects. For example, if you are editing the Model View matrix and you use the glRotatef function (I’ll cover this more later in the tutorial) to do a rotation operation, the result will be the object itself rotating, not the camera. To better remember it just remember that the camera is affected by projection and the objects are affected by model view.

Since the last two lines in the Resize function is changing the matrix to Model View and then loading the identity matrix, any matrix manipulations such as rotation or translation will affect only the objects.

Translation
If you remember from the previous tutorials, in the Render function we created, one of the first lines was a call to glTranslatef which was then filled with the parameters to move the object 4 units away from the viewer on the z-axis.

If you notice in the Render function code, after the glClear function call, the identity matrix is loaded with glLoadIdentity and then a translation operation occurs with the glTranslatef function:

//clear color and depth buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity;//load identity matrix glTranslatef(0.0f,0.0f,-4.0f);//move forward 4 units

Because of the identity matrix loading every time the Render function is called, the translation that occurs after that stays the same. Now lets say you were to take out the glLoadIdentity function in the Render function. Go ahead and do that, compile and run the program. What happened? Well, if all you saw was the colored shape for like a millisecond and then it started zooming away at a fast pace, then the object (the colored shape) was being translated at a constant rate without stopping. Since we set the translation operation to move the object away from the viewer 4 units, every time the Render function was called (which could be hundreds of times a second depending on the speed of your computer), the object moved away 4 units. But with the call to glLoadIdentity at the beginning of the Render function, the object will only be translated just 4 units away.

So far all we have done is translate along the z-axis. The glTranslatef function takes as three parameters the x, y, and z units, in that order, to translate the object. Lets do some examples with the other axis.

Translating along the X – axis
The first example I will explain will show an animation of a polygon moving back and forth along the x – axis. For this example I am using the “polygon” project files from the third tutorial about primitives.

The way I will do this animation is by first declaring two global variables. The first variable called “xTrans” is of type float and I initially set it to 0.0f. The “xTrans” variable is going to keep track of the amount to translate along the x-axis. The second variable is called “xDir” and is of type integer and is initially set to 1. The “xDir” variable will determine which direction the polygon will go on the x-axis. If the value is 1, then the polygon will move right along the x-axis. If the value is 0, then the polygon will move left along the x-axis:

float xTrans = 0.0f;//keeps track of X translation int xDir = 1;//1-right,0-left

Now going to the Render function, right after the glTranslatef function call that moves the object 4 units on the x-axis away from the user, we need first to check which direction that the polygon is moving. For that we create an IF statement that checks the value of the “xDir” variable and sees if it has the value of 1, meaning the polygon is moving to the right. Also within that IF statement, we also need to check to make sure that the polygon doesn’t move offscreen by checking that the “xTrans” variable is less than 2.0f, which is how many units to the right that is visible to the user. If both of these statements are true, then we increment the “xTrans” variable by a value of 0.1f. If the statements aren’t true, that means that the polygon has gone all the way to the right of the window and needs to reverse direction. We do that by setting the “xDir” variable to 0, meaning that the polygon will move to the left on the x-axis:

//checking if polygon can move right along x-axis if(xDir==1 && xTrans<2.0f) {        xTrans+=0.1f;//increment xTrans }    else//polygon has reached the right edge {        xDir=0;//change direction }

Now we do the same thing over again, except we check for a value of 0 for the “xDir” variable and make sure that the “xTrans” variable is greater than –2.0f, which is the left side of the window. If the statements are correct, then we decrement (make less) the value in “xTrans” by –0.1f. If the statements are false, we set “xDir” to 1 so that the polygon starts moving to the right along the x-axis:

//checking if polygon can move left along x-axis if(xDir==0 && xTrans>-2.0f) {        xTrans-=0.1f;//decrement xTrans }    else//polygon has reached the left edge {        xDir=1;//change direction }

After all that we need to actually perform the translation. After both IF statements, create a call to glTranslatef and put in for the first parameter the “xTrans” variable and leave the last two parameters as 0.0f:

//translate along the x-axis glTranslatef(xTrans,0.0f,0.0f);

Now when you compile and run the program, you should get a polygon that is moving fast to the right and left of the window.

Following is the whole Render function, followed by a sample output of this example. To see the entire code of this program, open the “xTranslate” project folder in the downloadable files:

void Render {         //clear color and depth buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity;//load identity matrix glTranslatef(0.0f,0.0f,-4.0f);//move forward 4 units //checking if polygon can move right along x-axis if(xDir==1 && xTrans<2.0f) {        xTrans+=0.1f;//increment xTrans }    else//polygon has reached the right edge {        xDir=0;//change direction }    //checking if polygon can move left along x-axis if(xDir==0 && xTrans>-2.0f) {        xTrans-=0.1f;//decrement xTrans }    else//polygon has reached the left edge {        xDir=1;//change direction }    //translate along the x-axis glTranslatef(xTrans,0.0f,0.0f); glColor3f(0.0f,0.0f,1.0f); //blue color glBegin(GL_POLYGON);//begin drawing of polygon glVertex3f(-0.5f,0.5f,0.0f);//first vertex glVertex3f(0.5f,0.5f,0.0f);//second vertex glVertex3f(1.0f,0.0f,0.0f);//third vertex glVertex3f(0.5f,-0.5f,0.0f);//fourth vertex glVertex3f(-0.5f,-0.5f,0.0f);//fifth vertex glVertex3f(-1.0f,0.0f,0.0f);//sixth vertex glEnd;//end drawing of polygon }

Translating along the y and z-axis can follow a similar process as shown above. Just make sure you know that when translating along the z-axis, moving along it in the positive direction will cause the object to get closer to you. So moving it along the negative direction will cause the object to get farther away from yo

Rotation
Rotation of an object involves moving an object around an axis. So if you were to rotate an object on the x-axis, then the object will rotate in a circle around the x-axis. This is the same with the other axis:

To achieve these rotations, we use the glRotatef function which takes as the first parameter the angle at which to rotate the object. The second, third, and fourth parameters are the x, y, and z axis, respectively, on which to rotate the object. For example, to rotate an object clockwise along the x-axis 90 degrees, you put in 90.0f for the first parameter in the glRotatef function, then put in 1.0f in the second parameter to indicate you want to rotate along the x-axis, and then leave the last two parameters as 0.0f:

glRotatef(90.0f,1.0f,0.0f,0.0f);

Rotating along the Y axis
For this example I am about to show you, we are going to take “polygon” example from the third tutorial and rotate the polygon along the y-axis. So open up the “polygon” example and try to follow along.

Just like the transformation example, we first need to declare a global variable called “yRot” which is of type float and initially set to 0.0f. This variable will hold the rotation angle:

float yRot = 0.0f;//variable to hold y rotation angle

Then in the Render function, right after the standard translation call, we call the glRotatef function with the first parameter being the “yRot” variable. The parameter is 0.0f indicating we are not rotating along the x-axis. The third parameter being 1.0f indicating we are rotating along the y-axis. Then the last parameter being 0.0f to indicate we do not want to rotate along the z-axis:

//rotate along the y-axis glRotatef(yRot,0.0f,1.0f,0.0f);

At the end of the Render function, we increment the “yRot” variable by 0.1f so that the polygon rotates at a constant rate:

yRot+=0.1f;//increment the yRot variable

Now compile and run the program and you should see your polygon rotating along the y-axis.

Following is the code for the whole Render function, followed by a sample output. To see the whole code, please refer to the “yRotation” project files included in the downloadable files:

void Render {         //clear color and depth buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity;//load identity matrix glTranslatef(0.0f,0.0f,-4.0f);//move forward 4 units //rotate along the y-axis glRotatef(yRot,0.0f,1.0f,0.0f); glColor3f(0.0f,0.0f,1.0f); //blue color glBegin(GL_POLYGON);//begin drawing of polygon glVertex3f(-0.5f,0.5f,0.0f);//first vertex glVertex3f(0.5f,0.5f,0.0f);//second vertex glVertex3f(1.0f,0.0f,0.0f);//third vertex glVertex3f(0.5f,-0.5f,0.0f);//fourth vertex glVertex3f(-0.5f,-0.5f,0.0f);//fifth vertex glVertex3f(-1.0f,0.0f,0.0f);//sixth vertex glEnd;//end drawing of polygon yRot+=0.1f;//increment the yRot variable }

Scaling
Scaling allows you to change the size of an object by however much you want it. To perform scaling you need to use the OpenGL function glScalef which takes as parameters the x, y, and z scale of the object. When putting in the parameters, you need to remember that the parameters in glScalef are multiplied by the original size of the object. For example, if you have a square drawn that is 1 unit wide and 1 unit high, to make the object two times the original size you would use 2.0f in the x and y parameters of the glScalef function to indicate that you want to double the size of the square:

In the diagram above I kept the z parameter to 1.0f to indicate not to change the depth of the square. Even though there really is no depth in this 2D square, you should still get into the habit of doing this, especially when we get into 3D drawing.

Scaling Example
For this example, I am going to use the “triangle” example from the third tutorial. We will modify the triangle program by showing an animation of the two triangles on the screen enlarging, almost filling up the screen, and then shrinking to the point you can’t see the triangles anymore. We will have this animation loop on its own.

The first thing I did to modify this program is declare three global variables. The first variable called “xScale” which is of type float and initially set to 0.0f will hold the scaling factor on the x-axis. The second variable called “yScale”, again of type float and set to 0.0f, holds the scaling factor in the y-axis. The third variable called “enlarge” is of type bool and initially set to “true”. This variable controls whether the triangles should enlarge (grow bigger) or shrink (get smaller). If this variable is set to true, the triangles enlarge, and false if they shrink:

float xScale = 0.01f;//x scale factor float yScale = 0.01f;//y scale factor bool enlarge = true;//true - enlarge, false - shrink

In the Render function, right after the glColor3f function call, we need to check if the triangles can be enlarged. We first create an IF statement that checks if the Boolean variable “enlarge” is true and makes sure that the “xScale” variable is less than 2.0 so that the triangles don’t enlarge more than double their size. If these statements are true, we then increment the “xScale” and “yScale” variables by 0.01f to allow for enlargement of the triangles. If the statements aren’t true, then we set the variable “enlarge” to false meaning we should start shrinking the triangles:

//check if triangles can be enlarged if(enlarge == true && xScale < 2.0f) {          xScale += 0.01f;//increment x scale yScale += 0.01f;//increment y scale }    else {          enlarge = false;//start shrinking }

After this we create another IF statement, but this time we check if the triangles can be shrunk. We check to make sure that the variable “enlarge” is set to false and that the “xScale” variable is greater than 0.0 so that the triangles don’t shrink on a scale of a negative scale. If both of these statements are true, then we decrement the “xScale” and “yScale” variables by 0.01f to allow shrinkage of the triangles. If the statements are not true, then we set the variable “enlarge” to true, meaning the triangles need to start enlarging:

//check if triangles can be shrunk if(enlarge == false && xScale > 0.0f) {          xScale -= 0.01f;//decrement x scale yScale -= 0.01f;//decrement y scale }    else {          enlarge = true;//start enlarging }

The last thing we need to do after all this is do the actual scaling. We make a call to the glScalef function with the first parameter being the “xScale” variable and the “yScale” variable being put in the second parameter. We keep the third parameter as 1.0f to indicate we are not scaling on the z-axis:

//scale triangles at a constant rate glScalef(xScale,yScale,1.0f);

Following is the whole Render function code followed by a sample output. If you want to view the whole code, please refer to the “xyScale” project folder on the downloadable files:

void Render {         //clear color and depth buffer glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity;//load identity matrix glTranslatef(0.0f,0.0f,-4.0f);//move forward 4 units glColor3f(0.0f,0.0f,1.0f); //blue color //check if triangles can be enlarged if(enlarge == true && xScale < 2.0f) {          xScale += 0.01f;//increment x scale yScale += 0.01f;//increment y scale }    else {          enlarge = false;//start shrinking }    //check if triangles can be shrunk if(enlarge == false && xScale > 0.0f) {          xScale -= 0.01f;//decrement x scale yScale -= 0.01f;//decrement y scale }    else {          enlarge = true;//start enlarging }    //scale triangles at a constant rate glScalef(xScale,yScale,1.0f); glBegin(GL_TRIANGLES);//start drawing triangles glVertex3f(-1.0f,-0.25f,0.0f);//triangle one first vertex glVertex3f(-0.5f,-0.25f,0.0f);//triangle one second vertex glVertex3f(-0.75f,0.25f,0.0f);//triangle one third vertex //drawing a new triangle glVertex3f(0.5f,-0.25f,0.0f);//triangle two first vertex glVertex3f(1.0f,-0.25f,0.0f);//triangle two second vertex glVertex3f(0.75f,0.25f,0.0f);//triangle two third vertex glEnd;//end drawing of triangles }

Custom Transformation and Rotation function
The last thing I would like to cover before we finish this tutorial is how to create a custom function to handle rotation and translation. I won’t be putting scaling in this function, but feel free to do that yourself if you feel like it.

The function I created is called “Transform” and has the return type of void. There are six parameters that are passed in which are all of type float. The first three parameters are the x,y, and z values of where to translate the object. They are called “xTrans”, “yTrans”, and “zTrans”. The last three parameters handle the x,y, and z values for rotation. They are called “xRot”, “yRot”, and “zRot”:

//custom function for transformations void Transform(float xTrans, float yTrans, float zTrans, float xRot, float yRot, float zRot) {

So within the function, we will first take care of the translation. All you have to do is make one call to the glTranslatef function, filling it in with the first three parameters of the Transform function:

//translate object glTranslatef(xTrans, yTrans, zTrans);

Now we will take care of the rotation. For this we make three separate calls to glRotatef filling the first parameter of each with the parameters passed to the Translate function. We then fill the rest of the parameters of glRotatef with a value of either 1.0f or 0.0f, depending on which variable we are rotating on:

//rotate along x-axis glRotatef(xRot,1.0f,0.0f,0.0f); //rotate along y-axis glRotatef(yRot,0.0f,1.0f,0.0f); //rotate along z-axis glRotatef(zRot,0.0f,0.0f,1.0f);

And that is all there is to the function. Here is the whole function listing. I also created an example program that uses this custom function. Look for it on the downloadable project files called “customTrans”. I have also listed here the call to the Transform function I did in this example program and a sample output:

//custom function for transformations void Transform(float xTrans, float yTrans, float zTrans, float xRot, float yRot, float zRot) {    //translate object glTranslatef(xTrans, yTrans, zTrans); //rotate along x-axis glRotatef(xRot,1.0f,0.0f,0.0f); //rotate along y-axis glRotatef(yRot,0.0f,1.0f,0.0f); //rotate along z-axis glRotatef(zRot,0.0f,0.0f,1.0f); }

//translate to upper - left corner and //rotate 45 degrees along the x,y, and z axis Transform(-1.0f,1.0f,0.0f,45.0f,45.0f,45.0f);

title: OpenGL Programming/GLStart/Tut4


text: US History/Great Depression and New Deal/Timeline


text:
User:HereToHelp

Please see my main account, w:User:HereToHelp.

title: User:HereToHelp


text:
User talk:HereToHelp

Please use the master HereToHelp talk page, w:User talk:HereToHelp.

title: User talk:HereToHelp


text: User talk:195.166.244.42

title: User talk:195.166.244.42


text:
Flute/Links

These are some good links to flute resources. One good article on flutes is on wikipedia.

Flute pages

 * Flute4All.com
 * FluteTunes.com
 * Fluteinfo.com
 * Flute.com
 * Flutes.tk
 * Larry Krank flute page

History of the Flute

 * flutehistory.com
 * Dayton C. Miller Flute Collection

Fingering charts

 * Jen Cluff's Fingering Chart PDF
 * Free Mobile Flute Fingering Chart
 * Fingering chart
 * Amro Flute Fingering Chart
 * Woodwind Fingering guide
 * Virtual Boehm Flute

Flute Acoustics

 * Flute Acousitcs

title: Flute/Links


text: Understanding C++/Quick Reference

title: Understanding C++/Quick Reference


text:
Esperanto: A Complete and Comprehensive Grammar/Word order

Word order
The earliest adopters of Esperanto used the subject-verb-object order used by almost all European languages. But thanks to the existence of the accusative and "various inflectional devices", plus the fact that the 16 rules in the Fundamento give little guidance in regards to word order, the French Esperantist Pierre Janton argues "that Esperanto syntax allows Japanese speakers to render 'the dog saw the cat' as 'la hundo la katon vidis' or Arabic speakers to say 'vidis la hundo la katon', just as they would in their own languages."

What about adjective-noun versus noun-adjective? Some languages allow both, but in English adjective-noun is generally preferred. Looking at Zamenhof's poem La Espero, one consistenly finds adjective noun: "forta voko," "facila vento," "sankta signo," etc.

But what about more complex, real-life sentences with more than one verb? A German speaker might naturally say, for example, "mi volas la kukon manĝi" ("I want the cake to eat"), while an English speaker would prefer "mi volas manĝi la kukon". Once such sentences got longer and more complex, they could become incomprehensible to people not accustomed to the speaker's preferred word order.


text:
User talk:88.107.225.117

Welcome!
Welcome to Wikibooks, a collection of open-content textbooks! You don't have to log in to read or edit articles on Wikibooks, but creating an account is quick, free and non-intrusive, requires no personal information, and gives you many benefits, including:
 * The use of a username of your choice
 * The ability to view all your contributions via a "My contributions" link
 * Your own user page
 * Your own talk page which, if you choose, also allows users to send you messages without knowing your e-mail address
 * The use of your own personal watchlist to which you can add articles that interest you
 * The ability to rename pages.
 * The ability to upload images
 * The ability to customize the appearance and behavior of the website
 * The eligibility to become an administrator
 * The right to be heard in votes and elections
 * Your IP address will no longer be visible to other users.

We hope that you choose to become a Wikibookian and create an account. Feel free to ask me any questions you may have on my talk page. By the way, make sure to sign your posts and comments with four tildes (~~~~), which will let others know who left it. --Derbeth talk 20:44, 16 September 2006 (UTC)

title: User talk:88.107.225.117


text:
User:*smb~enwikibooks

 * smb lives here. Feel free to say hi.

title: User:*smb~enwikibooks


text:
Talk:Algebra/Solving Equations

y=h-(g/v^2)X^2 Solve for v

Is this good English? Is this good wording ?
Quote:

Solving Equations

Although we have already solved a few equations, we will now discuss the formal idea of solving equations. ''To solve an equation, you are finding the value of any variables within the equation. To find the value of a variable, you have to manipulate the equation to state * insertvariablehere * = * somenumber *. Then you know the value of the variable! You will use the Properties of Equality to manipulate the equation into the desired form.

Andre anckaert (talk) 10:11, 8 January 2010 (UTC)

title: Talk:Algebra/Solving Equations


text:
The Housework Manual/Introduction

= Introduction =

House work is something that everyone in the world has to deal with. Whether that means doing it yourself, relying on a spouse or parent or other family member to do it for you, or paying a professional housekeeper to do it.

title: The Housework Manual/Introduction