|
On Pixar's How We Do It[^] page (slide 13), they talk about what goes into each frame of a movie. Maybe I'm just being dense, but...
Let's assume the average movie is 90 minutes, or 5,400 seconds, long.
Each frame is 1/24 of a second, so there are 129,600 frames.
If each frame takes about 6 hours to render, that would be 777,600 hours.
They undoubtedly have some serious horsepower doing this rendering, so is that 777,600 computer hours?
"Old age is like a bank account. You withdraw later in life what you have deposited along the way." - Unknown
"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons
|
|
|
|
|
I am sure that are CPU time measurements.
Calculate it into years, then you will see.
However they must have amazing Pcs.
Cheers
You have the thought that modern physics just relay on assumptions, that somehow depends on a smile of a cat, which isn’t there.( Albert Einstein)
|
|
|
|
|
Fatbuddha 1 wrote: Calculate it into years, then you will see.
I did, hence the confusion.
"Old age is like a bank account. You withdraw later in life what you have deposited along the way." - Unknown
"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons
|
|
|
|
|
I suspect a large degree of parallelism in use.
|
|
|
|
|
A very very very big cluster .
And then several of them .
Have a nice weekend
cheers
You have the thought that modern physics just relay on assumptions, that somehow depends on a smile of a cat, which isn’t there.( Albert Einstein)
|
|
|
|
|
Or it could be "actual time"; they didn't say much about the granularity of their parallelism, maybe they render multiple frames in parallel, instead of multiple pixels?
I didn't read the whole "How We Do It" though
|
|
|
|
|
My guess is that you would find they are rendering in layers and then integrating the layers. This would allow them to render smaller areas of a frame in less time.
For example, you can render a background once and then render foreground characters that are smaller sections of a frame and thus render in less time, and then integrate them together.
I don't think you could do it all this way simply because of how the various parts of a frame may interact, but I think this could get you a better (smaller) time.
|
|
|
|
|
That's only 89 CPU years. Even with 180 computers, that's 6 months of rendering and they have much larger rendering farms.
You measure democracy by the freedom it gives its dissidents, not the freedom it gives its assimilated conformists.
|
|
|
|
|
They Have "LARGE" render farms... LARGE.
they can "cut corners" in some aspects of the Render procedurally.
they can layer and post process.. usually this is what they do however this causes the large "finish rendering" time because someone goes in and digitally touches up the shadow, or adjusts the intensity of the red in the fire in the background etc...
all the photo-realistic portraits that i've seen can usually be rendered in under a couple of hours(very detailed) but being the perfectionists that they are the artists like to go back in and tweek the resulting image, make the gem more sparkely, the drool wetter.. etc.
|
|
|
|
|
Yeah, that sounds right - even if a little on the 'light' side by today's standards.
Apparently, Pixar used about 1000 Sun UltraSPARC servers to do the original ToyStory. When they did the movie CARS, they used about 300 times the processing power.
Tom Duff tells us that they're looking at around 1.2 million cpu hours for a 1.5 hour movie.....
Here's where you can find some more facts and figures: real-time-toy-story-3d[^]
|
|
|
|
|
Thanks for that link.
"Old age is like a bank account. You withdraw later in life what you have deposited along the way." - Unknown
"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons
|
|
|
|
|
Anyone know about travel or comparison algorithm for n-ary tree.please help me..
|
|
|
|
|
If by 'travel' you mean traversal you might find this[^] useful.
Henry Minute
Do not read medical books! You could die of a misprint. - Mark Twain
Girl: (staring) "Why do you need an icy cucumber?"
“I want to report a fraud. The government is lying to us all.”
|
|
|
|
|
public void convertDoubleToDecimal(double value)
{
long num = Double.doubleToLongBits(value);
byte sign = (byte)((num & 0x8000000000000000L) >> 63);
long exp = (num & 0x7ff0000000000000L) >> 52;
int e = (int)exp - 1023;
long fraction = num & 0x000fffffffffffffL;
long valueBin = fraction | (1L << 52);
int[] valueBinArray = new int[53];
for (int i = 0; i < valueBinArray.length; i++)
valueBinArray[i] = (int)((valueBin & (long)Math.pow(2, i)) >> i);
long intPart = 0;
double fractionPart = 0;
if (e <= 0)
{
for (int i = e; i >= 0; i--)
intPart += valueBinArray[52 - (e - i)] * (int)Math.pow(2, i);
for (int i = -1; i >= -(52-e); i--)
fractionPart += valueBinArray[52 - (e - i)] * Math.pow(2, i);
}
else
{
for (int i = 0; i > -53; i--)
fractionPart += valueBinArray[i + 52] * Math.pow(2, i + e);
}
int decimalPlaces = 4;
long number = (long)(intPart * Math.pow(10, decimalPlaces));
number += (long)(fractionPart * Math.pow(10, decimalPlaces));
byte[] buffer = new byte[16];
buffer[0] = (byte)(number & 0x00000000000000ffL);
buffer[1] = (byte)((number & 0x000000000000ff00L) >> 8);
buffer[2] = (byte)((number & 0x0000000000ff0000L) >> 16);
buffer[3] = (byte)((number & 0x00000000ff000000L) >> 24);
buffer[4] = (byte)((number & 0x000000ff00000000L) >> 32);
buffer[5] = (byte)((number & 0x0000ff0000000000L) >> 40);
buffer[6] = (byte)((number & 0x00ff000000000000L) >> 48);
buffer[7] = (byte)((number & 0xff00000000000000L) >> 56);
buffer[8] = (byte)0;
buffer[9] = (byte)0;
buffer[10] = (byte)0;
buffer[11] = (byte)0;
buffer[12] = (byte)0;
buffer[13] = (byte)0;
buffer[14] = (byte)decimalPlaces;
buffer[15] = sign;
}
modified on Monday, October 12, 2009 2:29 PM
|
|
|
|
|
Is there a question associated with this post?
BTW please put your code within a code block (<pre></pre> tags) to improve readability.
|
|
|
|
|
There is no question. I just didn't know where to put my code.
modified on Monday, October 12, 2009 2:52 PM
|
|
|
|
|
If you want to share code or a technique, you write an article. These forums are for questions and discussion.
You measure democracy by the freedom it gives its dissidents, not the freedom it gives its assimilated conformists.
|
|
|
|
|
I Want Detect A Circle In A Image(this image is a form that contain marks (optical mark recognition or OMR )) Using c#
is exists any source code for it.
thanks if help me
best regards
mohammad reza
|
|
|
|
|
I suspect it's readily available as a commercial library or application if you search for it.
You measure democracy by the freedom it gives its dissidents, not the freedom it gives its assimilated conformists.
|
|
|
|
|
Hi,
this[^] seems to explain it pretty well.
Luc Pattyn
I only read code that is properly indented, and rendered in a non-proportional font; hint: use PRE tags in forum messages
Local announcement (Antwerp region): Lange Wapper? Neen!
|
|
|
|
|
I forgot.
Hough transforms had fallen out of my ear.
Thanks for the link.
Silver member by constant and unflinching longevity.
|
|
|
|
|
Hello!
I have a set that contains maximum 10^6 items. All item are 4^n number, where 0 <= n <= 11, all items have a price that can be 1 <= price <= 10^8. And I also have another number k, where k is 4^n number and 0 <= n <= 11. The items are ordered monotonically first according to size of numbers, then to prices.
I want to take the sum of the items that equal to number k, and the price is minimal.
The example:
A := {16(1),16(2),16(3),16(4),64(11)}and k=64. (format: Number (price) -> 16(1))
So, the solution is 16(1),16(2),16(3),16(4), because 1+2+3+4=10 smaller then 11.
Any idea?
Thanks!
|
|
|
|
|
The problem and your notation aren't clear.
|
|
|
|
|
This sounds like a homework problem, and if so, you should consult with your instructor. As the other poster had said, your problem is not entirely clear, may want to rephrase it.
"The clue train passed his station without stopping." - John Simmons / outlaw programmer
"Real programmers just throw a bunch of 1s and 0s at the computer to see what sticks" - Pete O'Hanlon
"Not only do you continue to babble nonsense, you can't even correctly remember the nonsense you babbled just minutes ago." - Rob Graham
|
|
|
|
|
Your problem sounds like the knapsack problem. 4^n just acts as item-id (given in this peculiar notation to confuse) while k is the capacity of the knapsack. Its easy to solve this problem using the method of dynamic programming. Brute-force approaches which rely on generating combination also exist.
|
|
|
|