static void printPixel(IMG_DeepShadow &fp, int x, int y) {
int i, d, depth;
const IMG_DeepShadowChannel *chp;
IMG_DeepPixelReader pixel(fp);
// Open the pixel
if (!pixel.open(x, y)) {
printf("\tUnable to open pixel [%d,%d]!\n", x, y);
return;
}
// Get the number of z-records for the pixel
depth = pixel.getDepth();
printf("Pixel[%d,%d][%d]\n", x, y, depth);
// Iterate over all channels in the DCM
for (i = 0; i < fp.getChannelCount(); i++) {
chp = fp.getChannel(i);
printf(" %5s = [", chp->getName());
if (depth) {
// Print first depth record
printTuple<float>(pixel.getData(*chp, 0), chp->getTupleSize());
// And the remaining depth records
for (d = 1; d < depth; d++) {
printf(", ");
printTuple<float>(pixel.getData(*chp, d), chp->getTupleSize());
}
}
printf("]\n");
}
}
bool RATDeepImageReader::canRead( const std::string &fileName )
{
IMG_DeepShadow file;
if ( file.open( fileName.c_str() ) && file.depthInterp() == IMG_COMPRESS_DISCRETE )
{
return true;
}
return false;
}
static void dumpOptions(IMG_DeepShadow &fp) {
const UT_Options * opt;
UT_WorkBuffer wbuf;
if (opt = fp.getTBFOptions()) {
wbuf.strcpy("DSM Options: ");
opt->appendPyDictionary(wbuf);
printf("%s\n", wbuf.buffer());
}
}
int
main(int argc, char *argv[])
{
// Init:
CMD_Args args;
args.initialize(argc, argv);
args.stripOptions("r:v");
if (args.argc() < 3)
{
usage(argv[0]);
return 1;
}
// Options:
int res = 256;
int verbose = 0;
if(args.found('r')) res = atoi(args.argp('r'));
if(args.found('v')) verbose = 1;
UT_String dcm_file, gdp_file;
gdp_file.harden(argv[argc-2]);
dcm_file.harden(argv[argc-1]);
#if 1
// Open GDP with samples:
GU_Detail gdp;
UT_BoundingBox bbox;
if (!gdp.load(gdp_file, 0).success())
{
cerr << "Cant open " << gdp_file << endl;
return 1;
}
// Points arrays and bbox details:
gdp.getBBox(&bbox);
int range = gdp.getNumPoints();
UT_Vector3Array positions(range);
UT_ValArray<int> indices(range);
const GEO_Point *ppt;
const GEO_PointList plist = gdp.points();
for (int i = 0; i < gdp.getNumPoints(); i++)
{
ppt = plist(i);
UT_Vector3 pos = ppt->getPos3();
positions.append(pos);
indices.append(i);
}
if (verbose)
cout << "Points in gdp : " << positions.entries() << endl;
// Point Grid structures/objects:
UT_Vector3Point accessor(positions, indices);
UT_PointGrid<UT_Vector3Point> pointgrid(accessor);
// Can we build it?
if (!pointgrid.canBuild(res, res, res))
{
cout << "Can't build the grid!" << endl;
return 1;
}
// Build it:
pointgrid.build(bbox.minvec(), bbox.size(), res, res, res);
if (verbose)
{
cout << "Point grid res : " << res << "x" << res << "x" << res << endl;
cout << "Bounding box size : " << bbox.size().x() << ", " << bbox.size().y() << ", " << bbox.size().z() << endl;
cout << "Bounding box center: " << bbox.center().x() << ", " << bbox.center().y() << ", " << bbox.center().z() << endl;
cout << "Pointgrid mem size : " << pointgrid.getMemoryUsage() << endl;
cout << "Voxel size is : " << pointgrid.getVoxelSize() << endl;
cout << "Total grid points : " << pointgrid.entries() << endl;
}
#endif
// Open rat (our random access, variable array length storage):
IMG_DeepShadow dsm;
dsm.setOption("compression", "0");
dsm.setOption("zbias", "0.05");
dsm.setOption("depth_mode", "nearest");
dsm.setOption("depth_interp", "discrete");
dsm.open(dcm_file, res*res, res);
dsm.getTBFOptions()->setOptionV3("bbox:min" , bbox.minvec());
dsm.getTBFOptions()->setOptionV3("bbox:max" , bbox.maxvec());
if (verbose)
cout << "DCM created res : " << res*res << "x" << res << endl;
#if 1
// db_* debug variables...
int db_index = 0;
int db_uindex = 0;
int db_av_iter = 0;
// Put point into deep pixels:
Locker locker;
Timer timer;
timer.start();
parallel_fillDCM(res, &dsm, &pointgrid, &positions, &locker);
cout << "Creation time : " << timer.current() << endl;
if (verbose)
{
cout << "Total voxels : " << db_index << endl;
cout << "Written voxel : " << db_uindex << endl;
cout << "Points per voxel : " << (float)db_av_iter / db_uindex << endl;
}
timer.start();
dsm.close();
cout << "Saving time : " << timer.current() << endl;
if (verbose)
cout << "Deep map closed." << endl;
return 0;
#endif
}
int main(int argc, char *argv[]) {
IMG_DeepShadow fp;
int xres, yres;
if (argc < 3 || !fp.open(argv[1])) {
usage(argv[0]);
}
char * sdfFileName = argv[2];
std::vector<std::string> channelNames;
// Read the texture options in the file
dumpOptions(fp);
// Query the resolution
fp.resolution(xres, yres);
printf("%s[%d,%d] (%d channels)\n", argv[1], xres, yres, fp.getChannelCount());
for (int i = 0; i < fp.getChannelCount(); i++) {
const IMG_DeepShadowChannel * chp = fp.getChannel(i);
printf("%s ", chp->getName());
if (strcmp(chp->getName(), "C") == 0) {
channelNames.push_back("R");
channelNames.push_back("G");
channelNames.push_back("B");
channelNames.push_back("A");
}
}
channelNames.push_back("Z");
channelNames.push_back("ZBack");
std::cout << std::endl;
DeepImage * deepImage = new DeepImage(xres, yres, channelNames);
std::cout << "Pre load" << std::endl;
printDeepImageStats(*deepImage);
IMG_DeepPixelReader pixel(fp);
const IMG_DeepShadowChannel * pzp = nullptr;
const IMG_DeepShadowChannel * ofp = nullptr;
const IMG_DeepShadowChannel * cp = nullptr;
for (int i = 0; i < fp.getChannelCount(); i++) {
if (strcmp(fp.getChannel(i)->getName(), "Pz") == 0)
pzp = fp.getChannel(i);
else if (strcmp(fp.getChannel(i)->getName(), "Of") == 0) {
ofp = fp.getChannel(i);
} else if (strcmp(fp.getChannel(i)->getName(), "C") == 0) {
cp = fp.getChannel(i);
}
}
// const IMG_DeepShadowChannel * chp;
const UT_Options * opt = fp.getTBFOptions();
std::string interp = opt->getOptionS("texture:depth_interp");
bool linearInterp = (interp.compare("continuous") == 0);
int numChannels = channelNames.size();
for (int y = 0; y < yres; ++y) {
for (int x = 0; x < xres; ++x) {
if (!pixel.open(x, y)) {
printf("\tUnable to open pixel [%d,%d]!\n", x, y);
return 0;
}
pixel.uncomposite(*pzp, *ofp, true);
// Get the number of z-records for the pixel
int numSamples = pixel.getDepth();
if (numSamples > 0) {
for (int d = 0; d < numSamples; ++d) {
std::vector<DeepDataType> values(numChannels);
// Get color:
const float * c = pixel.getData(*cp, d);
const float * pz = pixel.getData(*pzp, d);
const float * pzBack = pz;
if (linearInterp) {
if (d + 1 < numSamples) {
pzBack = pixel.getData(*pzp, d + 1);
} else {
continue;
}
}
for (int i = 0; i < cp->getTupleSize(); ++i) {
values[i] = c[i];
if (i < 3 && c[3] > 0.0) {
// Unpremult.
values[i] /= c[3];
}
}
values[4] = pz[0];
values[5] = pzBack[0];
// for (int i = 0; i < fp.getChannelCount(); i++) {
// chp = fp.getChannel(i);
// int offset = -1;
// if (strcmp(chp->getName(), "C") == 0) {
// offset = 0;
// } else if (strcmp(chp->getName(), "Pz") == 0) {
// offset = 4;
// }
// if (offset >= 0) {
// const float * p = pixel.getData(*chp, d);
// for (int t = 0; t < chp->getTupleSize(); ++t) {
// values[offset+t] = p[t];
// }
// }
// }
// values[5] = values[4];
// values[0] /= values[3]; values[1] /= values[3]; values[2] /= values[3];
deepImage->addSample(yres-y-1, x, values);
}
}
}
}
std::cout << "Post load" << std::endl;
printDeepImageStats(*deepImage);
DeepImageWriter writer(sdfFileName, *deepImage);
if (writer.open()) {
writer.write();
writer.close();
}
delete deepImage;
// Print the raw pixel data
// printPixel(fp, 0, 0);
// printPixel(fp, xres >> 1, 0);
// printPixel(fp, xres - 1, 0);
printPixel(fp, 0, yres >> 1);
printPixel(fp, xres >> 1, yres >> 1);
// printPixel(fp, xres - 1, yres >> 1);
// printPixel(fp, 0, yres - 1);
printPixel(fp, xres >> 1, yres - 1);
// printPixel(fp, xres - 1, yres - 1);
return 0;
}