sora/epfl-archive
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Disabled external gits

Browse Source
This commit is contained in:
choelzl
2022-04-07 18:46:57 +02:00
parent 88cb3426ad
commit 15e7120d6d
5316 changed files with 4563444 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

754
cs440-acg/ext/openexr/OpenEXR/exrmaketiled/makeTiled.cpp Normal file
View File

@@ -0,0 +1,754 @@
///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2012, Industrial Light & Magic, a division of Lucas
// Digital Ltd. LLC
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Industrial Light & Magic nor the names of
// its contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------
//
// Produce a tiled version of an OpenEXR image.
//
//----------------------------------------------------------------------------
#include "makeTiled.h"
#include "Image.h"
#include "ImfTiledInputPart.h"
#include "ImfTiledOutputPart.h"
#include "ImfInputPart.h"
#include "ImfOutputPart.h"
#include "ImfDeepScanLineInputPart.h"
#include "ImfDeepScanLineOutputPart.h"
#include "ImfDeepTiledInputPart.h"
#include "ImfDeepTiledOutputPart.h"
#include "ImfChannelList.h"
#include "ImfChannelList.h"
#include "ImfFrameBuffer.h"
#include "ImfStandardAttributes.h"
#include "ImathFun.h"
#include "Iex.h"
#include "ImfMisc.h"
#include <map>
#include <algorithm>
#include <iostream>
#include <vector>
#include "namespaceAlias.h"
using namespace IMF;
using namespace IMATH_NAMESPACE;
using namespace std;
namespace {
string
extToString (Extrapolation ext)
{
string str;
switch (ext)
{
case BLACK:
str = "black";
break;
case CLAMP:
str = "clamp";
break;
case PERIODIC:
str = "periodic";
break;
case MIRROR:
str = "mirror";
break;
}
return str;
}
int
mirror (int x, int w)
{
int d = divp (x, w);
int m = modp (x, w);
return (d & 1)? w - 1 - m: m;
}
template <class T>
double
sampleX (const TypedImageChannel<T> &channel,
int w,
double x,
int y,
Extrapolation ext)
{
//
// Sample an image channel at location (x, y), where
// x is a floating point number, and y is an integer.
//
int xs = IMATH_NAMESPACE::floor (x);
int xt = xs + 1;
double s = xt - x;
double t = 1 - s;
double vs=0.0;
double vt=0.0;
switch (ext)
{
case BLACK:
vs = (xs >= 0 && xs < w)? double (channel (xs, y)): 0.0;
vt = (xt >= 0 && xt < w)? double (channel (xt, y)): 0.0;
break;
case CLAMP:
xs = clamp (xs, 0, w - 1);
xt = clamp (xt, 0, w - 1);
vs = channel (xs, y);
vt = channel (xt, y);
break;
case PERIODIC:
xs = modp (xs, w);
xt = modp (xt, w);
vs = channel (xs, y);
vt = channel (xt, y);
break;
case MIRROR:
xs = mirror (xs, w);
xt = mirror (xt, w);
vs = channel (xs, y);
vt = channel (xt, y);
break;
}
return s * vs + t * vt;
}
template <class T>
double
sampleY (const TypedImageChannel<T> &channel,
int h,
int x,
double y,
Extrapolation ext)
{
//
// Sample an image channel at location (x, y), where
// x is an integer, and y is a floating point number.
//
int ys = IMATH_NAMESPACE::floor (y);
int yt = ys + 1;
double s = yt - y;
double t = 1 - s;
double vs=0.0;
double vt=0.0;
switch (ext)
{
case BLACK:
vs = (ys >= 0 && ys < h)? double (channel (x, ys)): 0.0;
vt = (yt >= 0 && yt < h)? double (channel (x, yt)): 0.0;
break;
case CLAMP:
ys = clamp (ys, 0, h - 1);
yt = clamp (yt, 0, h - 1);
vs = channel (x, ys);
vt = channel (x, yt);
break;
case PERIODIC:
ys = modp (ys, h);
yt = modp (yt, h);
vs = channel (x, ys);
vt = channel (x, yt);
break;
case MIRROR:
ys = mirror (ys, h);
yt = mirror (yt, h);
vs = channel (x, ys);
vt = channel (x, yt);
break;
}
return s * vs + t * vt;
}
template <class T>
T
filterX (const TypedImageChannel<T> &channel,
int w,
double x,
int y,
Extrapolation ext)
{
//
// Horizontal four-tap filter, centered on pixel (x + 0.5, y)
//
return T (0.125 * sampleX (channel, w, x - 1, y, ext) +
0.375 * sampleX (channel, w, x, y, ext) +
0.375 * sampleX (channel, w, x + 1, y, ext) +
0.125 * sampleX (channel, w, x + 2, y, ext));
}
template <class T>
T
filterY (const TypedImageChannel<T> &channel,
int h,
int x,
double y,
Extrapolation ext)
{
//
// Vertical four-tap filter, centered on pixel (x, y + 0.5)
//
return T (0.125 * sampleY (channel, h, x, y - 1, ext) +
0.375 * sampleY (channel, h, x, y, ext) +
0.375 * sampleY (channel, h, x, y + 1, ext) +
0.125 * sampleY (channel, h, x, y + 2, ext));
}
template <class T>
void
reduceX (const TypedImageChannel<T> &channel0,
TypedImageChannel<T> &channel1,
bool filter,
Extrapolation &ext,
bool odd)
{
//
// Shrink an image channel, channel0, horizontally
// by a factor of 2, and store the result in channel1.
//
int w0 = channel0.image().width();
int w1 = channel1.image().width();
int h1 = channel1.image().height();
if (filter)
{
//
// Low-pass filter and resample.
// For pixels (0, y) and (w1 - 1, y) in channel 1,
// the low-pass filter in channel0 is centered on
// pixels (0.5, y) and (w0 - 1.5, y) respectively.
//
double f = (w1 > 1)? double (w0 - 2) / (w1 - 1): 1;
for (int y = 0; y < h1; ++y)
for (int x = 0; x < w1; ++x)
channel1 (x, y) = filterX (channel0, w0, x * f, y, ext);
}
else
{
//
// Resample, skipping every other pixel, without
// low-pass filtering. In order to keep the image
// from sliding to the right if the channel is
// resampled repeatedly, we skip the rightmost
// pixel of every row on even passes, and the
// leftmost pixel on odd passes.
//
int offset = odd? ((w0 - 1) - 2 * (w1 - 1)): 0;
for (int y = 0; y < h1; ++y)
for (int x = 0; x < w1; ++x)
channel1 (x, y) = channel0 (2 * x + offset, y);
}
}
template <class T>
void
reduceY (const TypedImageChannel<T> &channel0,
TypedImageChannel<T> &channel1,
bool filter,
Extrapolation ext,
bool odd)
{
//
// Shrink an image channel, channel0, vertically
// by a factor of 2, and store the result in channel1.
//
int w1 = channel1.image().width();
int h0 = channel0.image().height();
int h1 = channel1.image().height();
if (filter)
{
//
// Low-pass filter and resample.
// For pixels (x, 0) and (x, h1 - 1) in channel 1,
// the low-pass filter in channel0 is centered on
// pixels (x, 0.5) and (x, h0 - 1.5) respectively.
//
double f = (h1 > 1)? double (h0 - 2) / (h1 - 1): 1;
for (int y = 0; y < h1; ++y)
for (int x = 0; x < w1; ++x)
channel1 (x, y) = filterY (channel0, h0, x, y * f, ext);
}
else
{
//
// Resample, skipping every other pixel, without
// low-pass filtering. In order to keep the image
// from sliding towards the top if the channel is
// resampled repeatedly, we skip the top pixel of
// every column on even passes, and the bottom pixel
// on odd passes.
//
int offset = odd? ((h0 - 1) - 2 * (h1 - 1)): 0;
for (int y = 0; y < h1; ++y)
for (int x = 0; x < w1; ++x)
channel1 (x, y) = channel0 (x, 2 * y + offset);
}
}
void
reduceX (const ChannelList &channels,
const set<string> &doNotFilter,
Extrapolation ext,
bool odd,
const Image &image0,
Image &image1)
{
//
// Shrink image image0 horizontally by a factor of 2,
// and store the result in image image1.
//
for (ChannelList::ConstIterator i = channels.begin();
i != channels.end();
++i)
{
const char *name = i.name();
const Channel &channel = i.channel();
bool filter = (doNotFilter.find (name) == doNotFilter.end());
switch (channel.type)
{
case IMF::HALF:
reduceX (image0.typedChannel<half> (name),
image1.typedChannel<half> (name),
filter, ext, odd);
break;
case IMF::FLOAT:
reduceX (image0.typedChannel<float> (name),
image1.typedChannel<float> (name),
filter, ext, odd);
break;
case IMF::UINT:
reduceX (image0.typedChannel<unsigned int> (name),
image1.typedChannel<unsigned int> (name),
filter, ext, odd);
break;
default :
break;
}
}
}
void
reduceY (const ChannelList &channels,
const set<string> &doNotFilter,
Extrapolation ext,
bool odd,
const Image &image0,
Image &image1)
{
//
// Shrink image image0 vertically by a factor of 2,
// and store the result in image image1.
//
for (ChannelList::ConstIterator i = channels.begin();
i != channels.end();
++i)
{
const char *name = i.name();
const Channel &channel = i.channel();
bool filter = (doNotFilter.find (name) == doNotFilter.end());
switch (channel.type)
{
case IMF::HALF:
reduceY (image0.typedChannel<half> (name),
image1.typedChannel<half> (name),
filter, ext, odd);
break;
case IMF::FLOAT:
reduceY (image0.typedChannel<float> (name),
image1.typedChannel<float> (name),
filter, ext, odd);
break;
case IMF::UINT:
reduceY (image0.typedChannel<unsigned int> (name),
image1.typedChannel<unsigned int> (name),
filter, ext, odd);
break;
default :
break;
}
}
}
void
storeLevel (TiledOutputPart &out,
const ChannelList &channels,
int lx,
int ly,
const Image &image)
{
//
// Store the pixels for level (lx, ly) in output file out.
//
FrameBuffer fb;
for (ChannelList::ConstIterator i = channels.begin();
i != channels.end();
++i)
{
const char *name = i.name();
fb.insert (name, image.channel(name).slice());
}
out.setFrameBuffer (fb);
for (int y = 0; y < out.numYTiles (ly); ++y)
for (int x = 0; x < out.numXTiles (lx); ++x)
out.writeTile (x, y, lx, ly);
}
} // namespace
void
makeTiled (const char inFileName[],
const char outFileName[],
int partnum,
LevelMode mode,
LevelRoundingMode roundingMode,
Compression compression,
int tileSizeX,
int tileSizeY,
const set<string> &doNotFilter,
Extrapolation extX,
Extrapolation extY,
bool verbose)
{
Image image0;
Image image1;
Image image2;
Header header;
FrameBuffer fb;
vector<Header> headers;
//
// Load the input image
//
MultiPartInputFile input (inFileName);
int parts = input.parts();
for (int p = 0 ; p < parts; p++)
{
if (verbose)
cout << "reading file " << inFileName << endl;
if(p == partnum)
{
InputPart in (input, p);
header = in.header();
if (hasEnvmap (header) && mode != ONE_LEVEL)
{
//
// Proper low-pass filtering and subsampling
// of environment maps is not implemented in
// this program.
//
throw IEX_NAMESPACE::NoImplExc ("This program cannot generate "
"multiresolution environment maps. "
"Use exrenvmap instead.");
}
image0.resize (header.dataWindow());
for (ChannelList::ConstIterator i = header.channels().begin();
i != header.channels().end();
++i)
{
const char *name = i.name();
const Channel &channel = i.channel();
if (channel.xSampling != 1 || channel.ySampling != 1)
{
throw IEX_NAMESPACE::InputExc ("Sub-sampled image channels are "
"not supported in tiled files.");
}
image0.addChannel (name, channel.type);
image1.addChannel (name, channel.type);
image2.addChannel (name, channel.type);
fb.insert (name, image0.channel(name).slice());
}
in.setFrameBuffer (fb);
in.readPixels (header.dataWindow().min.y, header.dataWindow().max.y);
//
// Generate the header for the output file by modifying
// the input file's header
//
header.setTileDescription (TileDescription (tileSizeX, tileSizeY,
mode, roundingMode));
header.compression() = compression;
header.lineOrder() = INCREASING_Y;
if (mode != ONE_LEVEL)
addWrapmodes (header, extToString (extX) + "," + extToString (extY));
//
// set tileDescription, type, and chunckcount for multipart
//
header.setType(TILEDIMAGE);
int chunkcount = getChunkOffsetTableSize(header, true);
header.setChunkCount(chunkcount);
headers.push_back(header);
}
else
{
Header h = input.header(p);
headers.push_back(h);
}
}
//
// Store the highest-resolution level of the image in the output file
//
MultiPartOutputFile output (outFileName, &headers[0], headers.size());
for(int p = 0 ; p < parts; p++)
{
if (p == partnum)
{
try
{
TiledOutputPart out (output, partnum);
// TiledOutputFile out (outFileName, header);
out.setFrameBuffer (fb);
if (verbose)
cout << "writing file " << outFileName << "\n"
"level (0, 0)" << endl;
for (int y = 0; y < out.numYTiles (0); ++y)
for (int x = 0; x < out.numXTiles (0); ++x)
out.writeTile (x, y, 0);
//
// If necessary, generate the lower-resolution mipmap
// or ripmap levels, and store them in the output file.
//
if (mode == MIPMAP_LEVELS)
{
for (int l = 1; l < out.numLevels(); ++l)
{
image1.resize (out.dataWindowForLevel (l, l - 1));
reduceX (header.channels(),
doNotFilter,
extX,
l & 1,
image0,
image1);
image0.resize (out.dataWindowForLevel (l, l));
reduceY (header.channels(),
doNotFilter,
extY,
l & 1,
image1,
image0);
if (verbose)
cout << "level (" << l << ", " << l << ")" << endl;
storeLevel (out, header.channels(), l, l, image0);
}
}
if (mode == RIPMAP_LEVELS)
{
Image *iptr0 = &image0;
Image *iptr1 = &image1;
Image *iptr2 = &image2;
for (int ly = 0; ly < out.numYLevels(); ++ly)
{
if (ly < out.numYLevels() - 1)
{
iptr2->resize (out.dataWindowForLevel (0, ly + 1));
reduceY (header.channels(),
doNotFilter,
extY,
ly & 1,
*iptr0,
*iptr2);
}
for (int lx = 0; lx < out.numXLevels(); ++lx)
{
if (lx != 0 || ly != 0)
{
if (verbose)
cout << "level (" << lx << ", " << ly << ")" << endl;
storeLevel (out, header.channels(), lx, ly, *iptr0);
}
if (lx < out.numXLevels() - 1)
{
iptr1->resize (out.dataWindowForLevel (lx + 1, ly));
reduceX (header.channels(),
doNotFilter,
extX,
lx & 1,
*iptr0,
*iptr1);
swap (iptr0, iptr1);
}
}
swap (iptr2, iptr0);
}
}
}
catch (const exception &e)
{
cerr << e.what() << endl;
}
}
else
{
Header header = headers[p];
std::string type = header.type();
if (type == TILEDIMAGE)
{
TiledInputPart in (input, p);
TiledOutputPart out (output, p);
out.copyPixels (in);
}
else if (type == SCANLINEIMAGE)
{
using std::max; InputPart in (input, p);
OutputPart out (output, p);
out.copyPixels (in);
}
else if (type == DEEPSCANLINE)
{
DeepScanLineInputPart in (input,p);
DeepScanLineOutputPart out (output,p);
out.copyPixels (in);
}
else if (type == DEEPTILE)
{
DeepTiledInputPart in (input,p);
DeepTiledOutputPart out (output,p);
out.copyPixels (in);
}
}
}
if (verbose)
cout << "done." << endl;
}