277 lines
5.9 KiB
C++
277 lines
5.9 KiB
C++
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (c) 2004, 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.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
//
|
|
// Image scaling and filtering functions.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "scaleImage.h"
|
|
|
|
#include <ImathLimits.h>
|
|
#include <ImathFun.h>
|
|
#include <algorithm>
|
|
#include <math.h>
|
|
|
|
|
|
using namespace IMF;
|
|
using namespace IMATH;
|
|
using std::min;
|
|
using std::max;
|
|
|
|
|
|
int
|
|
scaleInt (float f, int i)
|
|
{
|
|
return int (f * i + 0.5);
|
|
}
|
|
|
|
|
|
void
|
|
scaleX (float f,
|
|
int &w, int &h,
|
|
int &dw, int &dh,
|
|
int &dx, int &dy,
|
|
Array<Rgba> &pixels)
|
|
{
|
|
int dw1 = scaleInt (f, dw);
|
|
|
|
if (dw1 <= dw)
|
|
{
|
|
//
|
|
// Do nothing if the width of the data window
|
|
// woudn't increase by at least one pixel.
|
|
//
|
|
|
|
return;
|
|
}
|
|
|
|
w = scaleInt (f, w);
|
|
dx = scaleInt (f, dx);
|
|
|
|
//
|
|
// Copy the pixels to a temporary array
|
|
//
|
|
|
|
Array<Rgba> tmp (dw * dh);
|
|
|
|
for (int i = 0; i < dw * dh; ++i)
|
|
tmp[i] = pixels[i];
|
|
|
|
//
|
|
// Resize the original pixel array,
|
|
// and copy the pixels back into the
|
|
// resized array.
|
|
//
|
|
|
|
pixels.resizeErase (dw1 * dh);
|
|
|
|
f = float (dw - 1) / float (dw1 - 1);
|
|
|
|
for (int x = 0; x < dw1; ++x)
|
|
{
|
|
float x1 = x * f;
|
|
int xs = int (x1);
|
|
int xt = min (xs + 1, dw - 1);
|
|
float t = x1 - xs;
|
|
float s = 1 - t;
|
|
|
|
for (int y = 0; y < dh; ++y)
|
|
{
|
|
const Rgba &ps = tmp [y * dw + xs];
|
|
const Rgba &pt = tmp [y * dw + xt];
|
|
Rgba &p = pixels[y * dw1 + x];
|
|
|
|
p.r = ps.r * s + pt.r * t;
|
|
p.g = ps.g * s + pt.g * t;
|
|
p.b = ps.b * s + pt.b * t;
|
|
p.a = ps.a * s + pt.a * t;
|
|
}
|
|
}
|
|
|
|
dw = dw1;
|
|
}
|
|
|
|
|
|
void
|
|
scaleY (float f,
|
|
int &w, int &h,
|
|
int &dw, int &dh,
|
|
int &dx, int &dy,
|
|
Array<Rgba> &pixels)
|
|
{
|
|
int dh1 = scaleInt (f, dh);
|
|
|
|
if (dh1 <= dh)
|
|
{
|
|
//
|
|
// Do nothing if the height of the data window
|
|
// woudn't increase by at least one pixel.
|
|
//
|
|
|
|
return;
|
|
}
|
|
|
|
h = scaleInt (f, h);
|
|
dy = scaleInt (f, dy);
|
|
|
|
//
|
|
// Copy the pixels to a temporary array
|
|
//
|
|
|
|
Array<Rgba> tmp (dw * dh);
|
|
|
|
for (int i = 0; i < dw * dh; ++i)
|
|
tmp[i] = pixels[i];
|
|
|
|
//
|
|
// Resize the original pixel array,
|
|
// and copy the pixels back into the
|
|
// resized array.
|
|
//
|
|
|
|
pixels.resizeErase (dw * dh1);
|
|
|
|
f = float (dh - 1) / float (dh1 - 1);
|
|
|
|
for (int y = 0; y < dh1; ++y)
|
|
{
|
|
float y1 = y * f;
|
|
int ys = int (y1);
|
|
int yt = min (ys + 1, dh - 1);
|
|
float t = y1 - ys;
|
|
float s = 1 - t;
|
|
|
|
for (int x = 0; x < dw; ++x)
|
|
{
|
|
const Rgba &ps = tmp [ys * dw + x];
|
|
const Rgba &pt = tmp [yt * dw + x];
|
|
Rgba &p = pixels[y * dw + x];
|
|
|
|
p.r = ps.r * s + pt.r * t;
|
|
p.g = ps.g * s + pt.g * t;
|
|
p.b = ps.b * s + pt.b * t;
|
|
p.a = ps.a * s + pt.a * t;
|
|
}
|
|
}
|
|
|
|
dh = dh1;
|
|
}
|
|
|
|
|
|
void
|
|
normalizePixels (int dw, int dh, Array<Rgba> &pixels)
|
|
{
|
|
float pMax = -IMATH::limits<float>::max ();
|
|
float pMin = IMATH::limits<float>::max ();
|
|
|
|
for (int i = 0; i < dw * dh; ++i)
|
|
{
|
|
const Rgba &p = pixels[i];
|
|
|
|
if (p.r.isFinite())
|
|
{
|
|
pMax = max (float (p.r), pMax);
|
|
pMin = min (float (p.r), pMin);
|
|
}
|
|
|
|
if (p.g.isFinite())
|
|
{
|
|
pMax = max (float (p.g), pMax);
|
|
pMin = min (float (p.g), pMin);
|
|
}
|
|
|
|
if (p.b.isFinite())
|
|
{
|
|
pMax = max (float (p.b), pMax);
|
|
pMin = min (float (p.b), pMin);
|
|
}
|
|
}
|
|
|
|
if (pMax <= pMin)
|
|
pMax = pMin + 1;
|
|
|
|
for (int i = 0; i < dw * dh; ++i)
|
|
{
|
|
Rgba &p = pixels[i];
|
|
|
|
if (p.r.isFinite())
|
|
p.r = (p.r - pMin) / (pMax - pMin);
|
|
|
|
if (p.g.isFinite())
|
|
p.g = (p.g - pMin) / (pMax - pMin);
|
|
|
|
if (p.b.isFinite())
|
|
p.b = (p.b - pMin) / (pMax - pMin);
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
swapPixels (int dw, int dh, Array<Rgba> &pixels)
|
|
{
|
|
Array<Rgba> tmp (max (dw, dh));
|
|
|
|
int dw2 = dw / 2;
|
|
int dh2 = dh / 2;
|
|
|
|
//
|
|
// Swap top and bottom half
|
|
//
|
|
|
|
for (int x = 0; x < dw; ++x)
|
|
{
|
|
for (int y = 0; y < dh; ++y)
|
|
tmp[(y + dh2) % dh] = pixels[dw * y + x];
|
|
|
|
for (int y = 0; y < dh; ++y)
|
|
pixels[dw * y + x] = tmp[y];
|
|
}
|
|
|
|
//
|
|
// Swap left and right half
|
|
//
|
|
|
|
for (int y = 0; y < dh; ++y)
|
|
{
|
|
for (int x = 0; x < dw; ++x)
|
|
tmp[(x + dw2) % dw] = pixels[dw * y + x];
|
|
|
|
for (int x = 0; x < dw; ++x)
|
|
pixels[dw * y + x] = tmp[x];
|
|
}
|
|
}
|