Jun 11

This model was created by Andrew Comb. It took six years to model in Lightwave 3D, and has a total of nine million polygons.

Once upon a time, a handful of pixels madeth the space invader. Graphics were iconic, not representative: a picture on the box or manual showed you what it was meant to look like, and your mind filled in the necessary gaps. Nobody could have predicted that in just 20 years, we’d be immersing ourselves in realistic living cities, flying over gorgeous tropical islands and going head-to-head with astoundingly rendered characters – and not even being particularly impressed. But in years to come, modern games like Grand Theft Auto IV and Crysis will look just as dated as the classics we remember from the days of yore. In fact, they’ll probably look more so: while the simplicity of a retro game’s look has a certain charm to it, old 3D titles tend to flat-out look old. Try almost any hit game of the mid-to-late ’90s for proof of that.

3D is about more than just pretty graphics. Done right, it makes gameworlds come alive. A 2D sprite can only do what it’s been drawn to do, while a 3D character has a complete endoskeleton and can respond naturally (at least in theory) to anything that happens – the classic example being ‘ragdolls’, where a fallen enemy doesn’t simply slump to the ground in a canned animation, but tumbles off the railing and lands with one arm draped over a step.

You can create worlds rather than merely levels, unlocking the player’s ability to truly explore and experience the world as the character would. You can build simulations ready to be poked and prodded, abused and enjoyed.

It’s phenomenally powerful, to the point that many nominally 2D games are now really 3D ones viewed from a locked perspective, so that they can better use the possibilities of animation, physics and art assets. Why render hundreds of frames of animation you may not be happy with when you can make a model and keep tweaking it until it’s perfect? You may lose some of the old-school charm, but you gain far more.

Dawn of a dimension

The first big 3D success was Battlezone, a tank game released in 1980 that used vector graphics to create its work, much like Asteroids. While a simple game by modern standards, it was fiendishly complex for such an early example, offering the ability to go anywhere in an (admittedly featureless) world, hide from attacks and fight enemies.

Battlezone was thought to be so realistic that the US Army used it to train tank gunners.

Not impressive enough? In 1987, the first Freescape game, Driller, hit the shelves. It offered a full 3D world on platforms as basic as the Spectrum, and was an actual game rather than just a tech demo. Next to that, it didn’t matter that it was ugly, the frame-rate was abysmal and the game itself wasn’t actually much fun – it got lots of attention.

The Freescape engine in its various forms was used in several famous releases, including Castle Master and its sequel, and the all-out 3D Construction Kit. Legend has it that someone somewhere once made something other than a surreal, unplayable mess in this, but we never saw it. Freescape also made it onto TV, in the form of the absolutely atrocious Craig Charles vehicle Cyberzone, one of the most toe-curling attempts at creating a games-related TV show ever. Thankfully, all that remains of it is a single YouTube clip – and that’s painful enough. Most of the early 3D games stuck to simpler technologies. These days, we think of 3D as free-roaming, real-time engines, but back in the day, simply getting a game to look 3D was impressive. As early as 1981, games were achieving this feat – 3D Monster Maze was terrifying a generation with its slowly updating screens and roaming T-Rex, and the first Ultima game was offering a very advanced hybrid of block-by-block movement 3D graphics for its dark dungeons alongside a top-
down 2D overworld for exploration.

Interestingly, while most developers kept pushing further towards 3D, Ultima ended up pulling back, switching entirely to a top-down sprite-based system for the series’ glory days. The 3D element later developed into its own spin-off – the Ultima Underworld games – before returning for the series’ sadly disappointing final outing – the buggy, system-murdering Ultima IX: Ascension.

Faking it

The problem has always been the same: the potential of 3D fights with the limitations of current systems, whether it’s simply displaying the graphics in the first place or making them look as good as other art styles. Going back to an early ’90s 3D game now is almost painful. Flat faces, non-moving lips during conversations, stick-figure character models, smeary textures and appalling animation… the list of problems goes on. Some games got past this, sometimes bizarrely – most obviously Core Design’s legendary heroine Lara Croft, who managed to become an international sex symbol despite looking like a pointy-chested Pinocchio. Most survived simply because playing a 3D game felt futuristic, even if the lack of polygons our PCs could push out meant that 2D games were usually much more detailed.

For much of 3D’s history, the trick has been getting the effect of the third dimension without having to do it for real. The early Wing Commander games gave the illusion that you were flying through 3D space, but really they were just scaling sprites up and down. In first-person shooters, it quickly became clear that walls were easy thanks to their incredibly simple geometry, but snarling hellbeasts dripping blood from their fangs were asking a bit too much. So developers compromised. The worlds themselves were made in 3D, initially just as mazes. Then, as texturing became more advanced, more realistic-looking areas were created, like those in Catacomb 3D.

Interestingly, the state of the art varied dramatically across genres. Shooters had to be fast and fluid, so they were kept simple. In the case of early games like Core Design’s Corporation, things were stripped down so much that the engine didn’t even bother with textures. Id’s first breakout hit – Wolfenstein 3D in 1992 – had textures to depict the inside of its supposed Nazi castle stronghold, but all the maps were completely flat and the interaction was limited to just opening doors and shooting enemies. Ultima Underworld, which came out in the same year, had sloped surfaces, advanced lighting effects, dialogue, puzzles, magic systems, physics, 3D objects, a real plot, the ability to look up and down instead of having your view locked straight ahead and much more.

Ultima Underworld could afford to push these limits because as a role-playing game, it was inherently slower than a shooter, and the audience was more willing to accept the necessary limitations, like the small viewing window. It didn’t hurt that while publisher Origin’s official motto was ‘We Create Worlds’, its unofficial credo was ‘Your PC Will Cry’. It never did worry about system requirements…

Two and a half dimensions

For performance and sales reasons, most games were stuck in what was dubbed 2.5D until the launch of Quake in 1996. Quake wasn’t the first genuinely full-3D shooter in the modern style, but it was the one that made 2.5D officially obsolete. These faux 3D or 2.5D games were flat maps, where areas could be raised and lowered (and in later games like Duke Nukem 3D, sloped), but you couldn’t have one room on top of another. Some games pretended otherwise, but it was generally a trick – the player would be silently teleported as they crossed the room’s threshold. Descent provided a full 3D world made up of polygons in 1995, but only a basic one – it was a series of sprawling mineshafts. The Star Wars game Dark Forces offered rooms above rooms, but otherwise stuck to the standard technologies on display in any other shooter of its era, including sprites.

First-person shooter bosses like this were unheard of before Quake was released in 1996. Now, they’re standard issue.

Sprites were a growing problem. By the mid ’90s, level design was getting more and more impressive. By modern standards, the opening cinema level in Duke Nukem Forever is empty and unconvincing, but to an audience used to bland military base corridors and castles, the realism was incredible.

Almost all these games were able to do this because they saved their 3D for the world. Actual characters were pre-drawn 2D images, pasted in to the game. Not only did they increasingly look weak, not part of the scenery and incredibly blocky up-close, but they also didn’t fit. Games could scale sprites to deal with the player getting closer to and further away from them, but when they started offering the ability to look up and down (first made popular with Heretic, a 1994 fantasy game) the effect showed its limits, with sprites shearing and increasingly looking like the cardboard cutouts they were.

A little voodoo magic

Games had to get more advanced, but the performance wasn’t there. Quake brought full-3D worlds and enemies to the field in 1996, but at the cost of visuals. Technically, they were better, and the improvement in animation was stunning – an early sequence where a snarling Fiend leaps out of a door to attack the player directly is one of many gamers’ fondest memories, to say nothing of the first episode’s room-
sized, lava-throwing monster Cthon. But the world was still drab, ugly and simplistic, with enemies that looked like they’d been knocked into shape with a sledgehammer and textures that would have lowered the tone in a morgue. Like all graphics technology, this quickly improved over the next few years, but it was increasingly obvious that simply throwing more CPU power at games wasn’t going to cut it.

Not alone, anyway

Most people didn’t really see the need for dedicated video cards at first because, to put it bluntly, there wasn’t much of one. Games increasingly offered a high-end mode that offered a higher resolution and additional effects without a specific need for extra hardware – bar a hefty processor. This high-end mode slowly became the standard experience, yet it was a long time before video cards became mandatory for playing PC games. Even technical showpieces like the original Unreal would run in so-called ‘software mode’. There wasn’t one big game that marked the transition, more a slow giving into inevitability.

Dedicated 3D cards came into their own around 1997, with several competing, mutually incompatible brands fighting it out for dominance. By far the most successful was 3DFX with its Voodoo cards. Even now, with built-in low-end 3D a standard on motherboards, a separate 3D card is mandatory for most games. On the plus side, the dominance of DirectX means that you don’t need to worry too much about which card to buy.

Individually, the abilities offered by 3D cards don’t sound too exciting. In the late ’90s, the core functions were transformation, clipping and lighting – in short, getting the card to work out where items in the world were and how they should be lit. The next big advance was the addition of shaders. Shaders are additional calculations thrown into the rendering pipeline that work on individual pixels, vertices and pieces of geometry to add effects and change the final image. Examples include working out appropriate shadows, making a flag flutter or adding bump mapping (a texture that gives the illusion of raised and lowered areas on an object without the need to add polygons). More advanced shaders include motion blur and bloom effects, soft shadows, depth of field and volumetric lighting.

The new bottlenecks

With the technology burden eased (or at least partly passed onto the card manufacturers), developers could focus on making the most of what they had. Valve largely pioneered skeletal-based characters rather than keyframe-by-keyframe animated enemies in Half-Life, and Ritual went out of its way to create interactive elements such as hackable computers in the real-
world environments of Half-Life’s closest rival of the time, Sin. Ragdolls spread to every new game until the games that didn’t offer them felt stodgy and ancient in comparison. Most importantly, the new realism of these games finally let developers sink their teeth into genres that they’d never have been able to do as traditional corridor shooters. Grand Theft Auto III gave us a living city. A million games brought the horrors of World War II to life in glorious cinematic style.

Realistic character and facial animation is a surprisingly recent addition to gaming.

Problem solved? No, just replaced. Now the issue became one of creating all this in the first place. A simple maze-based 3D shooter could be churned out in under a year by a competent team, but building cities, battlefields and other real-world elements requires an immense number of assets. Games are much shorter than they used to be, not because they’re more complicated – in most cases, the features are more advanced but the thinking is more conservative – because of the amount of content required, and the cost of making it. There are shortcuts for some things, like the Speedtree libraries for procedurally generating a forest in a hurry (used in, among many others, Grand Theft Auto IV, Elder Scrolls: Oblivion and Fallout 3), but in general, if a developer wants something, that developer has to make it himself.

Crysis 2 is the current state of the art: explore New York in the wake of an alien invasion.

Technology itself has also reached a plateau, not because there’s nothing more to do – nobody thinks that – but because right now, the big money is on Xbox 360 and PlayStation 3. Both are relatively old machines, but that doesn’t matter. PC ports often allow for higher resolutions and sometimes let you switch on better graphics (Metro 2033 looks much better for instance, as will Crysis 2 when it lands) but it’s usually a token gesture. To put the graphical difference into context, many PlayStation 3 games don’t even use anti-aliasing to smooth out the edges of their polygons, and games on both platforms typically render at a lower resolution than the high-def numbers you’d expect from the systems’ marketing.

Jun 07

Medical Billing And Electronic Claims Processing Services By: Rajeev Rajagopal


Medical billing and electronic claims processing services help in obtaining faster payments from insurers by reducing the time involved in preparing conventional paper claims. The service involves automated claim translation, database maintenance and reporting. Electronic claims processing ensures faster payment for clients. It also reduces your overhead cost by ruling out the labor cost required for printing, sorting and mailing.

Prominent Features of Electronic Claims Processing Services

Electronic claims processing firms upload the files to the bill payers employing a secure file transfer protocol (FTP). Before sending off to the payers, various techniques are utilized to match the bills with claim numbers. Electronic medical claims billing services utilize various advanced software packages such as Medical Manager, Eclipse, Medisoft, e-clinical, Misys, Lytec, Inception, Next Gen.

Electronic claims processing services offer multiple advantages such as automatic offsite backup and payment posting, claim tracking, bill customization, multiple payment posting, electronic patient statements, and secure internal messaging.

To ensure superior security, the entire electronic billing process is HIPAA compliant. It also ensures accurate keying by auditing the charges entered by charge entry. The main benefits of electronic claims processing services are:

• Reduced billing and insurance errors
• Timely management of clients’ accounts receivables
• Free direct access of data from any Internet enabled computer
• Fast turnaround time and improved cash flow
• Faster processing with quicker payment resolution
• No hardware or software installation and maintenance expense
• Low processing rates
• No upfront costs
• Backup and restore data
• Obtain timely reports and claims status information


Quality Medical Billing Services from Leading Outsourcing Firms

Nowadays you can find a number of outsourcing firms offering medical billing and electronic claims processing services. To get the best service, compare features and costs of various competitors in the industry. Reliable service providers offer precise billing solutions at affordable rates.

About the Author
Medical Billing and Electronic Claims Processing Services – Outsource Strategies International (OSI) is an established outsourcing firm based in Oklahoma, committed to providing variety of medical services including medical transcription, medical billing and coding.

(ArticlesBase SC #2024391)

Article Source: http://www.articlesbase.com/

Jun 03

Pentominoes, a simple educational toy, can reveal some surprisingly deep computer science. Although the first back-tracking solution to the puzzle was implemented in 1958, Donald Knuth devised an entirely new way of looking at the problem in 2000, and called the algorithm the Dancing Links algorithm (or more usually, DLX).
A pentomino set consists of 12 pieces, representing: all the different ways of joining 5 squares (hence pent-) along their edges to form an individual piece.

Be thankful you’re not assembling a set of 3D blocks. It’s even harder than the 2D version.

Figure 1 below shows the complete set, together with each piece’s usual name, a letter of the alphabet that most closely resembles it (F, I, L, N, P, T, U, V, W, X, Y, and Z). Since there are 12 pieces, each 5 squares in size, for a total of 60 squares, that means you could investigate solutions to fitting them all in a 3×20 rectangle, 4×15 rectangle, a 5×12 rectangle, or a 6×10 rectangle, as well as other, more fanciful, shapes.

Figure 1: The 12 pentominoes.

Back in my early teens, I was given a plastic set of Pentominoes arranged in a 6×10 box, presumably for my birthday or Christmas. I seem to remember then spending some inordinate amount of time over several months trying to find all the ways of arranging the pieces in the box. There are 2339 different ways, not counting rotations or reflections. I even used a notebook with squared paper to record the permutations I did discover (although I still have that pentomino set, the notebook has been lost in the mists of time). Needless to say, I did not find all 2339 ways.

Starting solutions

Figure 2 shows a solution for the 6×10 box (in fact, the solution I carefully kept with the box, since not knowing how to put them back would have been embarrassing), and if you look carefully, you’ll see that you can immediately generate another by swapping over T and F.

Figure 2: One of several possible solutions to the 6×10 pentomino puzzle.

After playing around with the pieces for a while, the natural question to ask is – well, natural if you are a programmer, that is – how can I write a program to generate all the solutions to a particular puzzle? Let’s look at what might be needed for a 3×20 rectangular board (there are 2 solutions to this particular puzzle, not counting rotations and reflections).

A first idea might be the following algorithm: take the pieces in order, F to Z. Place F somewhere on the empty board and mark off the squares it covers. Place the I on the board, making sure that it does not cover any of the already covered squares, and mark off the squares it does cover. Place the L likewise. At some point you will find that you won’t be able to place the next piece, so you should backtrack and move one of the already placed pieces to another position (perhaps also by rotating or flipping it over), and then try again. Continue this process, with the realization that you might have to backtrack several times at any one check, and eventually you will discover all permutations.

The big problem with this particular solution is that it will take some time. There are 144 different places and orientations for the F in a 3×20 board, 48 for the I, 136 for the L, and so on, and many of them will be completely illegal (for example, the F cannot appear right at the ends of the board, since in doing so you will always leave at least one empty square). So, in all you’ll be trying out 144 * 48 * 136 * … different permutations. Not very fast at all.

A better implementation might be to switch it around a little. Consider the square at the upper left of the board. Select a piece that covers it, and then mark off the remaining 4 squares that are also covered by this piece. Find the next uncovered square (for this type of board, because it’s so narrow, it’ll be better to search down the narrow axis rather than the long axis). Try and find a piece that covers that and that can be placed legally. If not, backtrack again and change a piece you’ve already placed. Sometimes you might have to backtrack several steps.

Because you are more likely to identify impossible solutions much quicker (for example, there are only 2 possible ways to place the F to cover the top left square and both are shown to be illegal when considering what to place in the next square downwards), you’ll find that this algorithm is much more efficient at identifying valid solutions because you reject invalid positions much earlier.

If you try and implement either of the above solutions, you’ll possibly find yourself calculating the positions and which squares are covered by each of the individual pieces over and over again. It would be better to calculate them once and for all and put the values in some kind of table that you read and process as you try out various placements.

Before we discuss the best data structure for that table, let’s take an aside and consider what’s known as the Exact Cover Problem. Imagine the following scenario. You are given a matrix of ones and zeros; that is, whose cells are either 1 or 0. The first part of Figure 3 shows such a matrix. The problem you have to solve is to work out which rows of the matrix form a set that contain exactly one 1 in each column. There may be no such set of rows, there may be exactly one, or there may be more than one. A solution to this problem is known as an exact cover: a set of rows that exactly covers the columns. Take a moment to work out the exact cover for Figure 3.

Figure 3: An exact cover problem in part 1; partial steps to a solution in parts 2 and 3.

Despite the ease with which a visual inspection will provide the answer with this small matrix (rows 2, 3, and 5), it’s well known that this problem is extremely hard (it’s NP-complete, in computer science terms) the more rows and columns there are.
The algorithm for solving it is recursive. Let’s follow along with Figure 3. You’re given a matrix. Choose a column (say the first). Choose a row such that the cell at the intersection of the column and row is a 1 (let’s go for row 4). Add that row to our solution. Now since that row will have a 1 in column 1 we must remove all the other rows that have a 1 in column 1 (that would be row 5). Not only that, but we must also remove all the rows that have a 1 in the same column as this chosen row. For row 4 we hit the jackpot: We can get rid of row 5 (again), row 2 and row 6. We remove row 4 (since it’s in our possible solution) and the three columns that row 4 covered (there’s no need to recheck them since we’ve already covered them). Our matrix now looks like the second part of Figure 3.

Reduced matrix

We do the same thing with this reduced matrix. We choose row 3 as our row since it intersects with column 2 in a 1. Unfortunately, we then have to delete row 1 as well since there’s a clash in column 6, meaning that columns 5 and 7 never get covered and we failed to get an exact cover. So we backtrack. Maybe choosing row 3 was the mistake. However, there is no other possibility to cover column 2 in that particular reduced matrix, and so we must backtrack to our choice of row 4, way at the beginning. Since that choice led to no exact cover, we see if we can’t make another choice of row to cover column 1. Yes, there is: row 5. Selecting row 5 means we get rid of rows 4, 4 (again), and 1, as well as columns 1, 3, and 7 (since row 5 covers them). We’re left with the reduced matrix shown in part 3 of Figure 3.

Here we make the choice of row 3, which removes row 6, as well as columns 2 and 6. And this, as I’m sure you can see, leaves us with row 2 covering the remaining two columns. (To be pedantic, we select row 2 which removes the final two columns as well. Since there are no rows or columns left, we found a solution.) Hence our exact cover solution is rows 2, 3, and 5.

All fine and dandy but what does this exact cover problem have to do with pentominoes, and in particular defining the table of where a piece can be placed and which squares it covers? The answer is to set up the puzzle as an exact cover problem. Let’s define the columns first: the initial 12 columns will be the pentomino pieces, one column for each piece. The next 60 columns will be one per square from the board, say counting from top left across the top row (1–20), then the second row (21–40), then the final row (41–60).

Now we can define each row as being a single piece placed on the board in a particular position. Since it’s a single piece, we’ll have a 1 in only one of the first 12 columns, according to which piece it is. Now we put a 1 in each column of the next 60 that corresponds to the squares covered by the piece in that position. For example, if we take F in its “normal” orientation and place it abutting the left side, the row will have a 1 under the F column, and a 1 under columns for squares 2, 3, 21, 22, 42. All the other 66 columns for that row will be 0. (In fact, every row we add to the matrix will contain 6 1′s and 66 0′s.)

How many rows will there be? Well, we just sum all the different ways we can place each piece. For example, for F there are 18 positions for each of its orientations, and 8 orientations, making 144 distinct positions. I did the calculation and came up with the following number of positions for each piece: F 144; I 48; L 136; N 68; P 220; T 72; U 110; V 72; W 72; X 18; Y 136; Z 72. In other words, the puzzle matrix has 1168 rows. This is one huge matrix, but note that it is very sparse: only 1 in 12 cells is a 1. Now all we have to do is to find the exact covers for this 72×1168 matrix. Because we haven’t done anything to avoid solutions that would be rotations or reflections of other solutions, we’ll actually find 4 times as many solutions as expected.

The fun problem is how to actually solve the exact cover problem efficiently. I’ve already noted that it’s a non-polynomial problem (probably exponential), so, for some large matrix, it’ll all get very hard to nigh on impossible, but this particular sparse, not-that-large matrix actually can be solved pretty quickly.

The algorithm to do it is the one I mentioned above (Donald Knuth calls this algorithm, Algorithm X), however, keeping track of all the rows and columns you’re removing or adding back – the housekeeping, if you like ¬– is quite complicated. To aid in this housekeeping issue, Knuth came up with a refinement that he called Algorithm DLX for something like “Dancing Links implementation of Algorithm X” (you can get the paper from this link, it’s paper P159).

Dancing Links?

Consider a doubly linked list where each node has a Next and a Prev reference to the next and previous nodes in the list. Then, in order to delete a given node X, all we have to do is set X.Next.Prev to X.Prev and X.Prev.Next to X.Next. X will no longer be in the linked list. However, providing that we don’t alter X in any way, we can just as easily add it back into the list: set both X.Next.Prev and X.Prev.Next to X. In other words, although the linked list has no more references to X, X itself still has “knowledge” of where it was in the list.

Well, all that is very well, but so what? Consider our 72×1168 sparse matrix, how would we represent that in memory? What data structure would we use? We could just use a simple standard matrix of boolean values, so it would take 84,096 cells, but such a structure is too rigid. Better would be to use a linked list of cells containing a 1 along each row. Knuth went even further: not only are the 1 cells joined in a linked list along each row, but they are equivalently joined up and down in a linked list as well. The matrix becomes a tapestry of linked lists, with each 1 cell having a link to its left, right, up, and down neighboring 1 cells. 0 cells are not stored at all.

Figure 4: A linked list tapestry for the exact cover problem deomstarted in Figure 3.

Figure 4 shows the exact cover problem matrix that we saw in Figure 3 as a linked list matrix. Each column has a header cell and the header cells have their own single header cell. The linked lists are circular lists: the links off to the left join at the right (and vice versa) and the links off the bottom join at the top (and vice versa). Now that we have this woven data structure of linked lists, we can make use of the remove/add-back-again idea that I just introduced. To cover a column we unlink it from the column headers linked list using our code and we can easily unlink the rows it contains by the same method. If we need to backtrack, we can add the rows back, in reverse order, and finally add the column back in. The housekeeping of Algorithm X is done through this property of deleted nodes “knowing” where they came from. We don’t have to have any special additional data structure to hold the removed rows and columns: the nodes themselves keep track of all that automatically.

In essence, Algorithm DLX finds an exact cover if, during a recursive call, the header of headers node points to itself. It fails to find one if there are still column headers but they have no rows; we shall then need to backtrack. To Knuth, looking at all the breaking and making of links, the weaving of the lists, it reminded him of a dance, hence the term Dancing Links.