While working with MS VC++ trying to create programs to create *.df3 I've found
it very difficult. I can only imagine how difficult it is, with the limited
number of converters, for people who have little or no C++ experience (such as
myself, never heard of big endian or little endian till working with *.df3
files in C++).

Would it be possible to include a *.df4 format where instead of dimension and
voxel data being in byte code, it was in some type of standard *.txt format?
Possibly ASCII? I realize it increase runtime (not sure how much, but I suppose
"Dramatically increase runtime" might be the right answer"). Even thought a
*.df4 option is included the *.df3 option can also be included for people where
runtime does matter.

Any possibility of this?

Post a reply to this message

Woody <nomail@nomail> wrote:
> Would it be possible to include a *.df4 format where instead of dimension and
> voxel data being in byte code, it was in some type of standard *.txt format?
> Possibly ASCII? I realize it increase runtime (not sure how much, but I suppose
> "Dramatically increase runtime" might be the right answer"). Even thought a
> *.df4 option is included the *.df3 option can also be included for people where
> runtime does matter.

  Nobody would write those files by hand anyways, so what's the point in
having them in readable ascii format?

  Writing the current DF3 file from a program (in basically any language)
is quite trivial. If you don't know how, just ask.

-- 
                                                          - Warp

Post a reply to this message

"Woody" <nomail@nomail> wrote:.
>
> Any possibility of this?

A good learning opportunity if nothing else (it was for me), but Paul Bourke's
page provides a full working c code to produce a df3 file.  Probably about a
five or ten minute effort and you could turn it into a conversion program.  Not
as accessible as a new format, but at least if you render it multiple times,
POV-Ray doesn't have to read an ASCII file every time.  Seems like a trivial
patch to switch it to ASCII-based df3 files too.

http://ozviz.wasp.uwa.edu.au/~pbourke/modelling_rendering/df3/
http://www.linuxjournal.com/article/7486

 - Ricky

Post a reply to this message

"triple_r" <rre### [at] hotmailcom> wrote:
> "Woody" <nomail@nomail> wrote:.
> >
> > Any possibility of this?
>
> A good learning opportunity if nothing else (it was for me), but Paul Bourke's
> page provides a full working c code to produce a df3 file.  Probably about a
> five or ten minute effort and you could turn it into a conversion program.  Not
> as accessible as a new format, but at least if you render it multiple times,
> POV-Ray doesn't have to read an ASCII file every time.  Seems like a trivial
> patch to switch it to ASCII-based df3 files too.
>
> http://ozviz.wasp.uwa.edu.au/~pbourke/modelling_rendering/df3/
> http://www.linuxjournal.com/article/7486
>
>  - Ricky

I did check out the first website. However I found the endian preprocessor macro
confusing. To be honest. I was never trained in plain C, only C++.

I used the VC++ toolkit MS put out in 2003. Anybody know any free C compilers
where this might work for an intel Machine?

Which Preprocessor Macro on the Paul Bourkes page should I be using?

Post a reply to this message

>   Writing the current DF3 file from a program (in basically any language)
> is quite trivial. If you don't know how, just ask.
>
> --
>                                                           - Warp

Warp,

If you every have a few moments do you think you could modify the source code
you posted at http://news.povray.org/4799ff49%40news.povray.org, so that it can
take one or more *.txt files specified in the command line (instead of the
testdata.txt) and output them into df3 format with the same name (except for
the txt extension).

If nothing is entered in the command line have it print the directions and a
"C++ Code developed by Warp". But this last part is just being needy on my part
and I can probably write that code myself.

-Jeff

Post a reply to this message

"Woody" <nomail@nomail> wrote:
> I did check out the first website. However I found the endian preprocessor macro
> confusing. To be honest. I was never trained in plain C, only C++.

Fair enough.  It could be worse though.  I suppose I was only 'trained' (hardly)
in Visual Basic (shudder) and Fortran (marginally less shudder).  So I agree,
but maybe this would be a good start:

http://www.space.unibe.ch/comp_doc/c_manual/C/CONCEPT/bitwise.html

> I used the VC++ toolkit MS put out in 2003. Anybody know any free C compilers
> where this might work for an intel Machine?

Doesn't work in VC++?  Haven't used that compiler and for that matter I don't do
much in C++, but I would think it would be mostly compatible.

http://en.wikipedia.org/wiki/Compatibility_of_C_and_C%2B%2B

> Which Preprocessor Macro on the Paul Bourkes page should I be using?

Hmm.  One then the other?  Can never remember.  Sorry I'm just dismissing your
questions with links, but the bottom line is that C/C++ is very easy to learn
since there are so many good webpages on the matter.  Takes some time, but it's
not bad.  Good luck.

 - Ricky

Post a reply to this message

>
>   Nobody would write those files by hand anyways, so what's the point in
> having them in readable ascii format?
>
>   Writing the current DF3 file from a program (in basically any language)
> is quite trivial. If you don't know how, just ask.
>
When you say no one writes them by hand anyway, do you mean its unlikely someone
would code each individual voxel in this manner?

I just thought sinc *.pov files and *.inc files are in ascii text it would make
sense to have non standard files (standard being GIF JPEG etc) also in txt so
they would be relatively easy to edit.

But your point is taken, that you are much more likely to edit a single line of
a POV or INC file then you are to edit a single voxel in a DF3 file.

Post a reply to this message

Woody <nomail@nomail> wrote:
> If you every have a few moments do you think you could modify the source code
> you posted at http://news.povray.org/4799ff49%40news.povray.org, so that it can
> take one or more *.txt files specified in the command line (instead of the
> testdata.txt) and output them into df3 format with the same name (except for
> the txt extension).

  You mean with the same input file format?
  How about this:


#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cstdio>

int main(int argc, char* argv[])
{
    // Limit the size of the df3 dimensions (safeguard against invalid input).
    // Maximum df3 size will be SIZE_LIMIT*SIZE_LIMIT*SIZE_LIMIT.
    const size_t SIZE_LIMIT = 256;

    if(argc < 2)
    {
        std::cout << "Usage: " << argv[0] << " <files>\n";
        return 0;
    }

    for(int i = 1; i < argc; ++i) // for each input file
    {
        std::ifstream is(argv[i]);
        if(!is.good())
        {
            std::cerr << "Couldn't open ";
            std::perror(argv[i]);
            continue;
        }

        size_t xSize, ySize, zSize;
        is >> xSize >> ySize >> zSize;
        if(xSize > SIZE_LIMIT || ySize > SIZE_LIMIT || zSize > SIZE_LIMIT)
        {
            std::cout << "Skipping " << argv[i] << " (invalid input)\n";
            continue;
        }

        std::vector<char> data(xSize*ySize*zSize + 6, 0);

        // Setup df3 header:
        data[0] = xSize/256; data[1] = xSize%256;
        data[2] = ySize/256; data[3] = ySize%256;
        data[4] = zSize/256; data[5] = zSize%256;

        // Read input data and create df3 data:
        while(true)
        {
            size_t x, y, z, value;
            is >> x >> y >> z >> value;
            if(!is.good()) break;
            const size_t ind = x + y*xSize + z*xSize*ySize + 6;
            if(ind < data.size())
                data[ind] = char(value);
        }

        // Write df3 file:
        std::string filename = argv[i];
        size_t ind = filename.find_last_of('.');
        if(ind != filename.npos) filename.resize(ind);
        filename += ".df3";
        std::ofstream os(filename.c_str(), std::ios::binary);
        os.write(&data[0], data.size());
        std::cout << argv[i] << " -> " << filename << std::endl;
    }
}

Post a reply to this message

Woody escribió:
> But your point is taken, that you are much more likely to edit a single line of
> a POV or INC file then you are to edit a single voxel in a DF3 file.
> 

And even if you wanted to edit a single voxel in a DF3, you could use an 
hex editor :)

Post a reply to this message

Warp wrote:
> Woody <nomail@nomail> wrote:
>> Would it be possible to include a *.df4 format where instead of dimension and
>> voxel data being in byte code, it was in some type of standard *.txt format?
>> Possibly ASCII? I realize it increase runtime (not sure how much, but I suppose
>> "Dramatically increase runtime" might be the right answer"). Even thought a
>> *.df4 option is included the *.df3 option can also be included for people where
>> runtime does matter.
> 
>   Nobody would write those files by hand anyways, so what's the point in
> having them in readable ascii format?
> 
>   Writing the current DF3 file from a program (in basically any language)
> is quite trivial. If you don't know how, just ask.

But some might want to use POV-Ray SDL to write them...

=)

-- 
Tor Olav
http://subcube.com

Post a reply to this message

Tor Olav Kristensen <tor### [at] toberemovedgmailcom> wrote:
> But some might want to use POV-Ray SDL to write them...

  Then it would be better to enhance the SDL (or better yet, redesign it
from scratch) so that you can create DF3's with it, rather than change
the DF3 so that you can create them with the current SDL...

  The latter only helps creating DF3 files. The former helps creating
tons of other files too.

-- 
                                                          - Warp

Post a reply to this message

Warp wrote:
> Tor Olav Kristensen <tor### [at] toberemovedgmailcom> wrote:
>> But some might want to use POV-Ray SDL to write them...
> 
>   Then it would be better to enhance the SDL (or better yet, redesign it
> from scratch) so that you can create DF3's with it, rather than change
> the DF3 so that you can create them with the current SDL...
> 
>   The latter only helps creating DF3 files. The former helps creating
> tons of other files too.

Yes, I agree.

-- 
Tor Olav
http://subcube.com

Post a reply to this message

in news:web.47b586279e245a8f94e61a50@news.povray.org Woody wrote:

> Would it be possible to include a *.df4 format where instead of
> dimension and voxel data being in byte code, it was in some type of
> standard *.txt format? Possibly ASCII?

Have a look at the PGM file format 
http://netpbm.sourceforge.net/doc/pgm.html it supports multiple layers. I 
don't know how much of the spec is supported by POV-Ray, I doubt it deals 
with multiple images.

Ingo

Post a reply to this message

Tor Olav Kristensen <tor### [at] TOBEREMOVEDgmailcom> wrote:

> But some might want to use POV-Ray SDL to write them...

Yes. Sometimes ago I needed to write df3 files from SDL, but that's impossible.
On the other side, Povray read only df files in binary format. I think that one
would want to create df3 files in his macros...

Post a reply to this message

Antonio Ferrari escribió:
> Tor Olav Kristensen <tor### [at] TOBEREMOVEDgmailcom> wrote:
> 
>> But some might want to use POV-Ray SDL to write them...
> 
> Yes. Sometimes ago I needed to write df3 files from SDL, but that's impossible.
> On the other side, Povray read only df files in binary format. I think that one
> would want to create df3 files in his macros...
> 

Yep, so let's add binary-file-writing capabilities to POV SDL, like Warp 
said. Not make an ASCII-based df3.

Post a reply to this message

Nicolas Alvarez <nic### [at] gmailisthebestcom> wrote:
> Antonio Ferrari escribió:
> > Tor Olav Kristensen <tor### [at] TOBEREMOVEDgmailcom> wrote:
> >
> >> But some might want to use POV-Ray SDL to write them...
> >
> > Yes. Sometimes ago I needed to write df3 files from SDL, but that's impossible.
> > On the other side, Povray read only df files in binary format. I think that one
> > would want to create df3 files in his macros...
> >
>
> Yep, so let's add binary-file-writing capabilities to POV SDL, like Warp
> said. Not make an ASCII-based df3.

that sounds like a fine idea. my main objection with the binary versuses the
ascii formats was that all the tutirials on the df3 binary format made things
alot more complicated with stuff like big indian and little indian. but im
assuming that if the ability to write binaries would make this trival, at the
very least there would be documentation as it applies to pov as opposed to
general computing

Post a reply to this message

Hi list,

I'm trying to use a density file in povray for the first time and the page is
always blank.

I use an external program to generate a file data.dat which looks like this,

10 10 10
0 0 0 240
1 0 0 240
2 0 0 240
3 0 0 240
4 0 0 240
5 0 0 240
6 0 0 240
7 0 0 240
8 0 0 240
etc ...

where the first line gives the dimensions, the first three columns are xyz
coordinates and last column the density value.

I use the c++ code posted here to create a df3 file. OK so far, I think.
Unfortunately, my basic example shows a blank page with nothing in it. I don't
know if the df3 file is incorrect or if it's a problem with the povray file
below,


background { color rgb <1.0,1.0,1.0> }
global_settings {
ambient_light <0.3,0.3,0.3>
}

#include "colors.inc"
#include "textures.inc"

light_source{<10,10,-10> color White}
#declare dist = 1.5;


camera {location <dist , dist ,dist>
right <0, 4/3, 0>
 up    <0,0,1>
 look_at  <0.0 , 0.0 , 0.0>}


#declare theinterior = interior {
   media {
      density {
         density_file df3 "data.df3"
         interpolate 1
         color_map {
            [0.00 rgb <0,0,0>]
            [0.2 rgb <0,0,1>]
            [0.4 rgb <0,1,0>]
            [1.00 rgb <1,0,0>]
         }
      }
   }
}

box {
   <0,0,0>, <1,1,1>
   pigment { rgbf 1 }
   interior { theinterior }
   hollow
}


I'll appreciate any advice.

Regards,

baptiste



Warp <war### [at] tagpovrayorg> wrote:
> Woody <nomail@nomail> wrote:
> > If you every have a few moments do you think you could modify the source code
> > you posted at http://news.povray.org/4799ff49%40news.povray.org, so that it can
> > take one or more *.txt files specified in the command line (instead of the
> > testdata.txt) and output them into df3 format with the same name (except for
> > the txt extension).
>
>   You mean with the same input file format?
>   How about this:
>
>
> #include <iostream>
> #include <fstream>
> #include <vector>
> #include <string>
> #include <cstdio>
>
> int main(int argc, char* argv[])
> {
>     // Limit the size of the df3 dimensions (safeguard against invalid input).
>     // Maximum df3 size will be SIZE_LIMIT*SIZE_LIMIT*SIZE_LIMIT.
>     const size_t SIZE_LIMIT = 256;
>
>     if(argc < 2)
>     {
>         std::cout << "Usage: " << argv[0] << " <files>\n";
>         return 0;
>     }
>
>     for(int i = 1; i < argc; ++i) // for each input file
>     {
>         std::ifstream is(argv[i]);
>         if(!is.good())
>         {
>             std::cerr << "Couldn't open ";
>             std::perror(argv[i]);
>             continue;
>         }
>
>         size_t xSize, ySize, zSize;
>         is >> xSize >> ySize >> zSize;
>         if(xSize > SIZE_LIMIT || ySize > SIZE_LIMIT || zSize > SIZE_LIMIT)
>         {
>             std::cout << "Skipping " << argv[i] << " (invalid input)\n";
>             continue;
>         }
>
>         std::vector<char> data(xSize*ySize*zSize + 6, 0);
>
>         // Setup df3 header:
>         data[0] = xSize/256; data[1] = xSize%256;
>         data[2] = ySize/256; data[3] = ySize%256;
>         data[4] = zSize/256; data[5] = zSize%256;
>
>         // Read input data and create df3 data:
>         while(true)
>         {
>             size_t x, y, z, value;
>             is >> x >> y >> z >> value;
>             if(!is.good()) break;
>             const size_t ind = x + y*xSize + z*xSize*ySize + 6;
>             if(ind < data.size())
>                 data[ind] = char(value);
>         }
>
>         // Write df3 file:
>         std::string filename = argv[i];
>         size_t ind = filename.find_last_of('.');
>         if(ind != filename.npos) filename.resize(ind);
>         filename += ".df3";
>         std::ofstream os(filename.c_str(), std::ios::binary);
>         os.write(&data[0], data.size());
>         std::cout << argv[i] << " -> " << filename << std::endl;
>     }
> }

Post a reply to this message

Am 26.08.2010 23:40, schrieb bapt:

> #declare theinterior = interior {
>     media {
>        density {
>           density_file df3 "data.df3"
>           interpolate 1
>           color_map {
>              [0.00 rgb<0,0,0>]
>              [0.2 rgb<0,0,1>]
>              [0.4 rgb<0,1,0>]
>              [1.00 rgb<1,0,0>]
>           }
>        }
>     }
> }

You might consider this a case of "POV-Ray fails to help you with a 
useful error message": Your media has a density, but no type. Is it 
supposed to be absorbing, emitting or scattering?

Post a reply to this message

clipka <ano### [at] anonymousorg> wrote:
> Am 26.08.2010 23:40, schrieb bapt:
>
> > #declare theinterior = interior {
> >     media {
> >        density {
> >           density_file df3 "data.df3"
> >           interpolate 1
> >           color_map {
> >              [0.00 rgb<0,0,0>]
> >              [0.2 rgb<0,0,1>]
> >              [0.4 rgb<0,1,0>]
> >              [1.00 rgb<1,0,0>]
> >           }
> >        }
> >     }
> > }
>
> You might consider this a case of "POV-Ray fails to help you with a
> useful error message": Your media has a density, but no type. Is it
> supposed to be absorbing, emitting or scattering?

I see, I added the following but still get a blank page,

#declare theinterior = interior {
   media {
    emission <1,1,1> / 10
     absorption <1,1,1> / 30
     scattering { 1, <0,0,0> }
      density {
         density_file df3 "data.df3"
         interpolate 1
         color_map {
            [0.00 rgb <0,0,0>]
            [0.2 rgb <0,0,1>]
            [0.4 rgb <0,1,0>]
            [1.00 rgb <1,0,0>]
         }
      }
   }
}

Thanks for helping,

baptiste

Post a reply to this message

Am 27.08.2010 07:39, schrieb bapt:

>> You might consider this a case of "POV-Ray fails to help you with a
>> useful error message": Your media has a density, but no type. Is it
>> supposed to be absorbing, emitting or scattering?
>
> I see, I added the following but still get a blank page,
>
> #declare theinterior = interior {
>     media {
>      emission<1,1,1>  / 10
>       absorption<1,1,1>  / 30
>       scattering { 1,<0,0,0>  }
>        density {
>           density_file df3 "data.df3"
>           interpolate 1
>           color_map {
>              [0.00 rgb<0,0,0>]
>              [0.2 rgb<0,0,1>]
>              [0.4 rgb<0,1,0>]
>              [1.00 rgb<1,0,0>]
>           }
>        }
>     }
> }

- Emission will be invisible, as your background is plain white.

- You can leave out scattering, as with a value of <0,0,0> it does 
nothing (the scattering color specifies how much the red, green and blue 
components of the light will be affected).

- Your absorption is simply too weak. Try absorption <1,1,1>*30 instead. 
Depends on how dense your density map actually is, though. Note that the 
smaller the distances in your scene are, the higher your media 
parameters have to be for the same effect.

Post a reply to this message

clipka <ano### [at] anonymousorg> wrote:
> Am 27.08.2010 07:39, schrieb bapt:
>
> >> You might consider this a case of "POV-Ray fails to help you with a
> >> useful error message": Your media has a density, but no type. Is it
> >> supposed to be absorbing, emitting or scattering?
> >
> > I see, I added the following but still get a blank page,
> >
> > #declare theinterior = interior {
> >     media {
> >      emission<1,1,1>  / 10
> >       absorption<1,1,1>  / 30
> >       scattering { 1,<0,0,0>  }
> >        density {
> >           density_file df3 "data.df3"
> >           interpolate 1
> >           color_map {
> >              [0.00 rgb<0,0,0>]
> >              [0.2 rgb<0,0,1>]
> >              [0.4 rgb<0,1,0>]
> >              [1.00 rgb<1,0,0>]
> >           }
> >        }
> >     }
> > }
>
> - Emission will be invisible, as your background is plain white.
>
> - You can leave out scattering, as with a value of <0,0,0> it does
> nothing (the scattering color specifies how much the red, green and blue
> components of the light will be affected).
>
> - Your absorption is simply too weak. Try absorption <1,1,1>*30 instead.
> Depends on how dense your density map actually is, though. Note that the
> smaller the distances in your scene are, the higher your media
> parameters have to be for the same effect.


Hi again,

I really appreciate your comments. Still not working though. I'm using megapov
on a Mac by the way, if it should make any difference.

Is there somewhere I could find a minimal example of what I should export as a
density file, some specification of what coordinates and values I should use to
see something within my box?

box {
   <0,0,0>, <1,1,1>
   pigment { rgbf 1 }
   interior { theinterior }
   }

I'm using R to create a table of values, with the following script

N <- 100
xx <- seq(0,1, length=N)
d <- expand.grid(x=xx,y=xx,z=xx)
d$t <- runif(nrow(d), 0, 255) # random values

cat(file="data.dat", "1 1 1\n")
write.table(d,file="data.dat",row.names = F,
            col.names = F,append=T)


Thanks,

baptiste

Post a reply to this message

Am 27.08.2010 12:35, schrieb bapt:

> Is there somewhere I could find a minimal example of what I should export as a
> density file, some specification of what coordinates and values I should use to
> see something within my box?

> I'm using R to create a table of values, with the following script
>
> N<- 100
> xx<- seq(0,1, length=N)
> d<- expand.grid(x=xx,y=xx,z=xx)
> d$t<- runif(nrow(d), 0, 255) # random values
>
> cat(file="data.dat", "1 1 1\n")
> write.table(d,file="data.dat",row.names = F,
>              col.names = F,append=T)

I'm sorry, I have no idea what "R" is.

To make sure what I told you would indeed to the trick, I generated a 
sample density file by adding the following additional statements at the 
beginning of the scene file you provided:

   #include "arrays.inc"

   #declare A = array[2][2][2] {
     { { 0.1, 0.2 }, { 0.3, 0.4 } },
     { { 0.5, 0.6 }, { 0.7, 0.8 } }
   }

   ARRAYS_WriteDF3(A, "data.df3", 8)

(using POV-Ray 3.7 beta 38; it won't work with POV-Ray 3.6)

This would correspond to a 2x2x2 grid, with cells filled as follows:

   0,0,0   26
   0,0,1   51
   0,1,0	  77
   0,1,1  102
   1,0,0  153
   1,0,1  179
   1,1,0  204

This does work - for example - with absorption <1,1,1>*30 on a white 
background, or emission<1,1,1>*10 on a black background.

If you still can't get this to work, then something's broken in your 
workflow. Otherwise, you're just still too cautious about the absorption 
values to get your own density files working. Be bold to try out some 
insanely large values - you can't physically break anything ;-)

Post a reply to this message

clipka <ano### [at] anonymousorg> wrote:
> Am 27.08.2010 12:35, schrieb bapt:
>
> > Is there somewhere I could find a minimal example of what I should export as a
> > density file, some specification of what coordinates and values I should use to
> > see something within my box?
>
> > I'm using R to create a table of values, with the following script
> >
> > N<- 100
> > xx<- seq(0,1, length=N)
> > d<- expand.grid(x=xx,y=xx,z=xx)
> > d$t<- runif(nrow(d), 0, 255) # random values
> >
> > cat(file="data.dat", "1 1 1\n")
> > write.table(d,file="data.dat",row.names = F,
> >              col.names = F,append=T)
>
> I'm sorry, I have no idea what "R" is.
>
> To make sure what I told you would indeed to the trick, I generated a
> sample density file by adding the following additional statements at the
> beginning of the scene file you provided:
>
>    #include "arrays.inc"
>
>    #declare A = array[2][2][2] {
>      { { 0.1, 0.2 }, { 0.3, 0.4 } },
>      { { 0.5, 0.6 }, { 0.7, 0.8 } }
>    }
>
>    ARRAYS_WriteDF3(A, "data.df3", 8)
>
> (using POV-Ray 3.7 beta 38; it won't work with POV-Ray 3.6)
>
> This would correspond to a 2x2x2 grid, with cells filled as follows:
>
>    0,0,0   26
>    0,0,1   51
>    0,1,0   77
>    0,1,1  102
>    1,0,0  153
>    1,0,1  179
>    1,1,0  204
>
> This does work - for example - with absorption <1,1,1>*30 on a white
> background, or emission<1,1,1>*10 on a black background.
>
> If you still can't get this to work, then something's broken in your
> workflow. Otherwise, you're just still too cautious about the absorption
> values to get your own density files working. Be bold to try out some
> insanely large values - you can't physically break anything ;-)

Damn, it's so close but... no luck. I cannot install POV-Ray 3.7 for some reason
(Mac) and the values above run through the c++ script still give me a blank
page. Would you mind posting the df3 and pov files so I can rule out the
conversion and know for sure that my povray is broken? I have cranked up the
absorption well above reasonable values and it's still all white.

Thanks,

baptiste

Post a reply to this message

Am 27.08.2010 17:23, schrieb bapt:

> Damn, it's so close but... no luck. I cannot install POV-Ray 3.7 for some reason
> (Mac) and the values above run through the c++ script still give me a blank
> page. Would you mind posting the df3 and pov files so I can rule out the
> conversion and know for sure that my povray is broken? I have cranked up the
> absorption well above reasonable values and it's still all white.

Posted it in povray.binary.scene-files, I hope it helps. I must say that 
I assume your c++ program is broken in some way.

Post a reply to this message

clipka <ano### [at] anonymousorg> wrote:
> Am 27.08.2010 17:23, schrieb bapt:
>
> > Damn, it's so close but... no luck. I cannot install POV-Ray 3.7 for some reason
> > (Mac) and the values above run through the c++ script still give me a blank
> > page. Would you mind posting the df3 and pov files so I can rule out the
> > conversion and know for sure that my povray is broken? I have cranked up the
> > absorption well above reasonable values and it's still all white.
>
> Posted it in povray.binary.scene-files, I hope it helps. I must say that
> I assume your c++ program is broken in some way.

Thanks, that's very helpful. It seems to work now.

Cheers,

baptiste

Post a reply to this message

> - Your absorption is simply too weak. Try absorption <1,1,1>*30 instead.
> Depends on how dense your density map actually is, though. Note that the
> smaller the distances in your scene are, the higher your media
> parameters have to be for the same effect.

If you want realistic results, each component of absorption must be 
equal to or greater than the emission component.  Making them equal 
gives you a pure glowing effect, whereas adding a bit more absorption 
gives you some smokiness.

In nature, everything which emits light also absorbs that same frequency 
of light to the same degree.  We see only the light that is at the 
outermost edges of the glowing object, but we're used to this.

Regards,
John

Post a reply to this message

What do I need to do to modify the program code shown below, so that the first
line of the data file, instead of taking 3 parameters (Size of each dimension),
takes 4 arguments (Size of each of the three dimensins + bit resolution type).
Where the bit resolution type is 8, 16 or 32bit.


> Warp <war### [at] tagpovrayorg> wrote:
> > Woody <nomail@nomail> wrote:
> > > If you every have a few moments do you think you could modify the source code
> > > you posted at http://news.povray.org/4799ff49%40news.povray.org, so that it can
> > > take one or more *.txt files specified in the command line (instead of the
> > > testdata.txt) and output them into df3 format with the same name (except for
> > > the txt extension).
> >
> >   You mean with the same input file format?
> >   How about this:
> >
> >
> > #include <iostream>
> > #include <fstream>
> > #include <vector>
> > #include <string>
> > #include <cstdio>
> >
> > int main(int argc, char* argv[])
> > {
> >     // Limit the size of the df3 dimensions (safeguard against invalid input).
> >     // Maximum df3 size will be SIZE_LIMIT*SIZE_LIMIT*SIZE_LIMIT.
> >     const size_t SIZE_LIMIT = 256;
> >
> >     if(argc < 2)
> >     {
> >         std::cout << "Usage: " << argv[0] << " <files>\n";
> >         return 0;
> >     }
> >
> >     for(int i = 1; i < argc; ++i) // for each input file
> >     {
> >         std::ifstream is(argv[i]);
> >         if(!is.good())
> >         {
> >             std::cerr << "Couldn't open ";
> >             std::perror(argv[i]);
> >             continue;
> >         }
> >
> >         size_t xSize, ySize, zSize;
> >         is >> xSize >> ySize >> zSize;
> >         if(xSize > SIZE_LIMIT || ySize > SIZE_LIMIT || zSize > SIZE_LIMIT)
> >         {
> >             std::cout << "Skipping " << argv[i] << " (invalid input)\n";
> >             continue;
> >         }
> >
> >         std::vector<char> data(xSize*ySize*zSize + 6, 0);
> >
> >         // Setup df3 header:
> >         data[0] = xSize/256; data[1] = xSize%256;
> >         data[2] = ySize/256; data[3] = ySize%256;
> >         data[4] = zSize/256; data[5] = zSize%256;
> >
> >         // Read input data and create df3 data:
> >         while(true)
> >         {
> >             size_t x, y, z, value;
> >             is >> x >> y >> z >> value;
> >             if(!is.good()) break;
> >             const size_t ind = x + y*xSize + z*xSize*ySize + 6;
> >             if(ind < data.size())
> >                 data[ind] = char(value);
> >         }
> >
> >         // Write df3 file:
> >         std::string filename = argv[i];
> >         size_t ind = filename.find_last_of('.');
> >         if(ind != filename.npos) filename.resize(ind);
> >         filename += ".df3";
> >         std::ofstream os(filename.c_str(), std::ios::binary);
> >         os.write(&data[0], data.size());
> >         std::cout << argv[i] << " -> " << filename << std::endl;
> >     }
> > }

Post a reply to this message

Woody <nomail@nomail> wrote:
> What do I need to do to modify the program code shown below, so that the first
> line of the data file, instead of taking 3 parameters (Size of each dimension),
> takes 4 arguments (Size of each of the three dimensins + bit resolution type).
> Where the bit resolution type is 8, 16 or 32bit.

  It requires quite some modifications because writing the larger integrals
is slightly more complicated, but this should do it:

//---------------------------------------------------------------------
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cstdio>
#include <cassert>

template<typename Int_t>
void writeIntValue(Int_t value, std::ostream& os)
{
    for(unsigned byteInd = sizeof(Int_t); byteInd-- > 0;)
        os << (unsigned char)((value >> (byteInd * 8)) & 0xFF);
}

template<typename Int_t>
void createDF3(std::istream& is, std::ostream& os,
               size_t xSize, size_t ySize, size_t zSize)
{
    std::vector<Int_t> data(xSize*ySize*zSize, 0);

    while(true)
    {
        size_t x, y, z, value;
        is >> x >> y >> z >> value;
        if(!is) break;
        const size_t ind = x + y*xSize + z*xSize*ySize;
        if(ind < data.size())
            data[ind] = Int_t(value);
    }

    for(size_t i = 0; i < data.size(); ++i)
        writeIntValue(data[i], os);
}

int main(int argc, char* argv[])
{
    // Limit the size of the df3 dimensions (safeguard against invalid input).
    // Maximum df3 size will be SIZE_LIMIT*SIZE_LIMIT*SIZE_LIMIT.
    const size_t SIZE_LIMIT = 256;

    typedef unsigned char Int8_t;
    typedef unsigned short Int16_t;
    typedef unsigned int Int32_t;
    assert(sizeof(Int16_t) == 2);
    assert(sizeof(Int32_t) == 4);

    if(argc < 2)
    {
        std::cout << "Usage: " << argv[0] << " <files>\n";
        return 0;
    }

    for(int i = 1; i < argc; ++i) // for each input file
    {
        std::ifstream is(argv[i]);
        if(!is.good())
        {
            std::cerr << "Couldn't open ";
            std::perror(argv[i]);
            continue;
        }

        size_t xSize, ySize, zSize, bits;
        is >> xSize >> ySize >> zSize >> bits;
        if(xSize > SIZE_LIMIT || ySize > SIZE_LIMIT || zSize > SIZE_LIMIT ||
           (bits != 8 && bits != 16 && bits != 32))
        {
            std::cout << "Skipping " << argv[i] << " (invalid input)\n";
            continue;
        }

        std::string filename = argv[i];
        size_t ind = filename.find_last_of('.');
        if(ind != filename.npos) filename.resize(ind);
        filename += ".df3";
        std::ofstream os(filename.c_str(), std::ios::binary);

        char header[6];
        header[0] = xSize/256; header[1] = xSize%256;
        header[2] = ySize/256; header[3] = ySize%256;
        header[4] = zSize/256; header[5] = zSize%256;
        os.write(header, 6);

        switch(bits)
        {
          case 8: createDF3<Int8_t>(is, os, xSize, ySize, zSize); break;
          case 16: createDF3<Int16_t>(is, os, xSize, ySize, zSize); break;
          case 32: createDF3<Int32_t>(is, os, xSize, ySize, zSize); break;
        }

        std::cout << argv[i] << " -> " << filename << std::endl;
    }
}
//---------------------------------------------------------------------

-- 
                                                          - Warp

Post a reply to this message

Warp <war### [at] tagpovrayorg> wrote:
> Woody <nomail@nomail> wrote:
> > What do I need to do to modify the program code shown below, so that the first
> > line of the data file, instead of taking 3 parameters (Size of each dimension),
> > takes 4 arguments (Size of each of the three dimensins + bit resolution type).
> > Where the bit resolution type is 8, 16 or 32bit.
>
>   It requires quite some modifications because writing the larger integrals
> is slightly more complicated, but this should do it:
>
> //---------------------------------------------------------------------
> #include <iostream>
> #include <fstream>
> #include <vector>
> #include <string>
> #include <cstdio>
> #include <cassert>
>
> template<typename Int_t>
> void writeIntValue(Int_t value, std::ostream& os)
> {
>     for(unsigned byteInd = sizeof(Int_t); byteInd-- > 0;)
>         os << (unsigned char)((value >> (byteInd * 8)) & 0xFF);
> }
>
> template<typename Int_t>
> void createDF3(std::istream& is, std::ostream& os,
>                size_t xSize, size_t ySize, size_t zSize)
> {
>     std::vector<Int_t> data(xSize*ySize*zSize, 0);
>
>     while(true)
>     {
>         size_t x, y, z, value;
>         is >> x >> y >> z >> value;
>         if(!is) break;
>         const size_t ind = x + y*xSize + z*xSize*ySize;
>         if(ind < data.size())
>             data[ind] = Int_t(value);
>     }
>
>     for(size_t i = 0; i < data.size(); ++i)
>         writeIntValue(data[i], os);
> }
>
> int main(int argc, char* argv[])
> {
>     // Limit the size of the df3 dimensions (safeguard against invalid input).
>     // Maximum df3 size will be SIZE_LIMIT*SIZE_LIMIT*SIZE_LIMIT.
>     const size_t SIZE_LIMIT = 256;
>
>     typedef unsigned char Int8_t;
>     typedef unsigned short Int16_t;
>     typedef unsigned int Int32_t;
>     assert(sizeof(Int16_t) == 2);
>     assert(sizeof(Int32_t) == 4);
>
>     if(argc < 2)
>     {
>         std::cout << "Usage: " << argv[0] << " <files>\n";
>         return 0;
>     }
>
>     for(int i = 1; i < argc; ++i) // for each input file
>     {
>         std::ifstream is(argv[i]);
>         if(!is.good())
>         {
>             std::cerr << "Couldn't open ";
>             std::perror(argv[i]);
>             continue;
>         }
>
>         size_t xSize, ySize, zSize, bits;
>         is >> xSize >> ySize >> zSize >> bits;
>         if(xSize > SIZE_LIMIT || ySize > SIZE_LIMIT || zSize > SIZE_LIMIT ||
>            (bits != 8 && bits != 16 && bits != 32))
>         {
>             std::cout << "Skipping " << argv[i] << " (invalid input)\n";
>             continue;
>         }
>
>         std::string filename = argv[i];
>         size_t ind = filename.find_last_of('.');
>         if(ind != filename.npos) filename.resize(ind);
>         filename += ".df3";
>         std::ofstream os(filename.c_str(), std::ios::binary);
>
>         char header[6];
>         header[0] = xSize/256; header[1] = xSize%256;
>         header[2] = ySize/256; header[3] = ySize%256;
>         header[4] = zSize/256; header[5] = zSize%256;
>         os.write(header, 6);
>
>         switch(bits)
>         {
>           case 8: createDF3<Int8_t>(is, os, xSize, ySize, zSize); break;
>           case 16: createDF3<Int16_t>(is, os, xSize, ySize, zSize); break;
>           case 32: createDF3<Int32_t>(is, os, xSize, ySize, zSize); break;
>         }
>
>         std::cout << argv[i] << " -> " << filename << std::endl;
>     }
> }
> //---------------------------------------------------------------------
>
> --
>                                                           - Warp

So does this always use 255 as the max voxel value regardless of the bit
resolution?

How does 255 (besides being 256 minus 1) relate to the bit resolution?

Sorry, I don't know a whole lot about bytes and bits.

Post a reply to this message

Woody <nomail@nomail> wrote:
> [-- text/plain, encoding 8bit, charset: iso-8859-1, 117 lines --]

> Warp <war### [at] tagpovrayorg> wrote:
> > Woody <nomail@nomail> wrote:
> > > What do I need to do to modify the program code shown below, so that the first
> > > line of the data file, instead of taking 3 parameters (Size of each dimension),
> > > takes 4 arguments (Size of each of the three dimensins + bit resolution type).
> > > Where the bit resolution type is 8, 16 or 32bit.
> >
> >   It requires quite some modifications because writing the larger integrals
> > is slightly more complicated, but this should do it:
> >
> > //---------------------------------------------------------------------
> > #include <iostream>
> > #include <fstream>
> > #include <vector>
> > #include <string>
> > #include <cstdio>
> > #include <cassert>
> >
> > template<typename Int_t>
> > void writeIntValue(Int_t value, std::ostream& os)
> > {
> >     for(unsigned byteInd = sizeof(Int_t); byteInd-- > 0;)
> >         os << (unsigned char)((value >> (byteInd * 8)) & 0xFF);
> > }
> >
> > template<typename Int_t>
> > void createDF3(std::istream& is, std::ostream& os,
> >                size_t xSize, size_t ySize, size_t zSize)
> > {
> >     std::vector<Int_t> data(xSize*ySize*zSize, 0);
> >
> >     while(true)
> >     {
> >         size_t x, y, z, value;
> >         is >> x >> y >> z >> value;
> >         if(!is) break;
> >         const size_t ind = x + y*xSize + z*xSize*ySize;
> >         if(ind < data.size())
> >             data[ind] = Int_t(value);
> >     }
> >
> >     for(size_t i = 0; i < data.size(); ++i)
> >         writeIntValue(data[i], os);
> > }
> >
> > int main(int argc, char* argv[])
> > {
> >     // Limit the size of the df3 dimensions (safeguard against invalid input).
> >     // Maximum df3 size will be SIZE_LIMIT*SIZE_LIMIT*SIZE_LIMIT.
> >     const size_t SIZE_LIMIT = 256;
> >
> >     typedef unsigned char Int8_t;
> >     typedef unsigned short Int16_t;
> >     typedef unsigned int Int32_t;
> >     assert(sizeof(Int16_t) == 2);
> >     assert(sizeof(Int32_t) == 4);
> >
> >     if(argc < 2)
> >     {
> >         std::cout << "Usage: " << argv[0] << " <files>\n";
> >         return 0;
> >     }
> >
> >     for(int i = 1; i < argc; ++i) // for each input file
> >     {
> >         std::ifstream is(argv[i]);
> >         if(!is.good())
> >         {
> >             std::cerr << "Couldn't open ";
> >             std::perror(argv[i]);
> >             continue;
> >         }
> >
> >         size_t xSize, ySize, zSize, bits;
> >         is >> xSize >> ySize >> zSize >> bits;
> >         if(xSize > SIZE_LIMIT || ySize > SIZE_LIMIT || zSize > SIZE_LIMIT ||
> >            (bits != 8 && bits != 16 && bits != 32))
> >         {
> >             std::cout << "Skipping " << argv[i] << " (invalid input)\n";
> >             continue;
> >         }
> >
> >         std::string filename = argv[i];
> >         size_t ind = filename.find_last_of('.');
> >         if(ind != filename.npos) filename.resize(ind);
> >         filename += ".df3";
> >         std::ofstream os(filename.c_str(), std::ios::binary);
> >
> >         char header[6];
> >         header[0] = xSize/256; header[1] = xSize%256;
> >         header[2] = ySize/256; header[3] = ySize%256;
> >         header[4] = zSize/256; header[5] = zSize%256;
> >         os.write(header, 6);
> >
> >         switch(bits)
> >         {
> >           case 8: createDF3<Int8_t>(is, os, xSize, ySize, zSize); break;
> >           case 16: createDF3<Int16_t>(is, os, xSize, ySize, zSize); break;
> >           case 32: createDF3<Int32_t>(is, os, xSize, ySize, zSize); break;
> >         }
> >
> >         std::cout << argv[i] << " -> " << filename << std::endl;
> >     }
> > }
> > //---------------------------------------------------------------------
> >
> > --
> >                                                           - Warp

> So does this always use 255 as the max voxel value regardless of the bit
> resolution?

> How does 255 (besides being 256 minus 1) relate to the bit resolution?

  Where do you see a 255 in the program?

  The maximum value for each voxel is dependent on the bit size. If you
are eg. using 16 bits, the maximum value is 65535.

-- 
                                                          - Warp

Post a reply to this message

Warp <war### [at] tagpovrayorg> wrote:
> Woody <nomail@nomail> wrote:
> > [-- text/plain, encoding 8bit, charset: iso-8859-1, 117 lines --]
>
> > Warp <war### [at] tagpovrayorg> wrote:
> > > Woody <nomail@nomail> wrote:
> > > > What do I need to do to modify the program code shown below, so that the first
> > > > line of the data file, instead of taking 3 parameters (Size of each
dimension),
> > > > takes 4 arguments (Size of each of the three dimensins + bit resolution type).
> > > > Where the bit resolution type is 8, 16 or 32bit.
> > >
> > >   It requires quite some modifications because writing the larger integrals
> > > is slightly more complicated, but this should do it:
> > >
> > > //---------------------------------------------------------------------
> > > #include <iostream>
> > > #include <fstream>
> > > #include <vector>
> > > #include <string>
> > > #include <cstdio>
> > > #include <cassert>
> > >
> > > template<typename Int_t>
> > > void writeIntValue(Int_t value, std::ostream& os)
> > > {
> > >     for(unsigned byteInd = sizeof(Int_t); byteInd-- > 0;)
> > >         os << (unsigned char)((value >> (byteInd * 8)) & 0xFF);
> > > }
> > >
> > > template<typename Int_t>
> > > void createDF3(std::istream& is, std::ostream& os,
> > >                size_t xSize, size_t ySize, size_t zSize)
> > > {
> > >     std::vector<Int_t> data(xSize*ySize*zSize, 0);
> > >
> > >     while(true)
> > >     {
> > >         size_t x, y, z, value;
> > >         is >> x >> y >> z >> value;
> > >         if(!is) break;
> > >         const size_t ind = x + y*xSize + z*xSize*ySize;
> > >         if(ind < data.size())
> > >             data[ind] = Int_t(value);
> > >     }
> > >
> > >     for(size_t i = 0; i < data.size(); ++i)
> > >         writeIntValue(data[i], os);
> > > }
> > >
> > > int main(int argc, char* argv[])
> > > {
> > >     // Limit the size of the df3 dimensions (safeguard against invalid input).
> > >     // Maximum df3 size will be SIZE_LIMIT*SIZE_LIMIT*SIZE_LIMIT.
> > >     const size_t SIZE_LIMIT = 256;
> > >
> > >     typedef unsigned char Int8_t;
> > >     typedef unsigned short Int16_t;
> > >     typedef unsigned int Int32_t;
> > >     assert(sizeof(Int16_t) == 2);
> > >     assert(sizeof(Int32_t) == 4);
> > >
> > >     if(argc < 2)
> > >     {
> > >         std::cout << "Usage: " << argv[0] << " <files>\n";
> > >         return 0;
> > >     }
> > >
> > >     for(int i = 1; i < argc; ++i) // for each input file
> > >     {
> > >         std::ifstream is(argv[i]);
> > >         if(!is.good())
> > >         {
> > >             std::cerr << "Couldn't open ";
> > >             std::perror(argv[i]);
> > >             continue;
> > >         }
> > >
> > >         size_t xSize, ySize, zSize, bits;
> > >         is >> xSize >> ySize >> zSize >> bits;
> > >         if(xSize > SIZE_LIMIT || ySize > SIZE_LIMIT || zSize > SIZE_LIMIT ||
> > >            (bits != 8 && bits != 16 && bits != 32))
> > >         {
> > >             std::cout << "Skipping " << argv[i] << " (invalid input)\n";
> > >             continue;
> > >         }
> > >
> > >         std::string filename = argv[i];
> > >         size_t ind = filename.find_last_of('.');
> > >         if(ind != filename.npos) filename.resize(ind);
> > >         filename += ".df3";
> > >         std::ofstream os(filename.c_str(), std::ios::binary);
> > >
> > >         char header[6];
> > >         header[0] = xSize/256; header[1] = xSize%256;
> > >         header[2] = ySize/256; header[3] = ySize%256;
> > >         header[4] = zSize/256; header[5] = zSize%256;
> > >         os.write(header, 6);
> > >
> > >         switch(bits)
> > >         {
> > >           case 8: createDF3<Int8_t>(is, os, xSize, ySize, zSize); break;
> > >           case 16: createDF3<Int16_t>(is, os, xSize, ySize, zSize); break;
> > >           case 32: createDF3<Int32_t>(is, os, xSize, ySize, zSize); break;
> > >         }
> > >
> > >         std::cout << argv[i] << " -> " << filename << std::endl;
> > >     }
> > > }
> > > //---------------------------------------------------------------------
> > >
> > > --
> > >                                                           - Warp
>
> > So does this always use 255 as the max voxel value regardless of the bit
> > resolution?
>
> > How does 255 (besides being 256 minus 1) relate to the bit resolution?
>
>   Where do you see a 255 in the program?
>
>   The maximum value for each voxel is dependent on the bit size. If you
> are eg. using 16 bits, the maximum value is 65535.
>
> --
>                                                           - Warp

I suppose I was seeing 255 from the sample I posted at
http://news.povray.org/4799ff49%40news.povray.org and was thinking that 255 was
the maximum.

Thanks Again for your help. :)


-Jeff

Post a reply to this message

Warp,

Do you know where I can find the POVRay volunteer wishlist? I think its also an
Amazon wishlist?

Who do I ask about where to have the items shipped?

-J

Post a reply to this message

Warp,

Do you know where I can find the POVRay volunteer wishlist? I think its also an
Amazon wishlist?

Who do I ask about where to have the items shipped?

-J

Post a reply to this message

El 01/02/11 14:23, Woody escribió:
>    Warp,
>
> Do you know where I can find the POVRay volunteer wishlist? I think its also an
> Amazon wishlist?

   It's empty at the moment:

http://www.amazon.com/wishlist/3HDAWHAITQIKL/ref=cm_wl_rlist_go

   Regards,

-- 
Jaime Vives Piqueres
		
La Persistencia de la Ignorancia
http://www.ignorancia.org

Post a reply to this message