248 lines
6 KiB
C++
248 lines
6 KiB
C++
|
|
|
|
#include "ttoonzimage.h"
|
|
#include "tpalette.h"
|
|
//#include "ttile.h"
|
|
//#include "transparencyCheck.h"
|
|
|
|
//---------------------------------------------------------
|
|
|
|
TToonzImage::TToonzImage()
|
|
: m_ras()
|
|
, m_dpix(0)
|
|
, m_dpiy(0)
|
|
, m_subsampling(1)
|
|
, m_name("")
|
|
, m_savebox()
|
|
//, m_hPos(0.0)
|
|
, m_offset(0, 0)
|
|
, m_size() {}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
TToonzImage::TToonzImage(const TRasterCM32P &ras, const TRect &saveBox)
|
|
: m_ras(ras)
|
|
, m_size(ras->getSize())
|
|
, m_dpix(0)
|
|
, m_dpiy(0)
|
|
, m_subsampling(1)
|
|
, m_name("")
|
|
, m_savebox(saveBox)
|
|
//, m_hPos(0.0)
|
|
, m_offset(0, 0) {
|
|
assert(ras->getBounds().contains(saveBox));
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
TToonzImage::TToonzImage(const TToonzImage &src)
|
|
: m_ras(TRasterCM32P())
|
|
, m_dpix(src.m_dpix)
|
|
, m_dpiy(src.m_dpiy)
|
|
, m_subsampling(src.m_subsampling)
|
|
, m_name(src.m_name)
|
|
, m_savebox(src.m_savebox)
|
|
//, m_hPos(src.m_hPos)
|
|
, m_offset(src.m_offset)
|
|
, m_size(src.m_size) {
|
|
if (src.m_ras) // src non e' compressa
|
|
{
|
|
m_ras = src.m_ras->clone();
|
|
} else {
|
|
assert(false);
|
|
assert(!src.m_ras);
|
|
}
|
|
|
|
TPalette *palette = src.getPalette();
|
|
if (palette) {
|
|
m_palette = palette->clone();
|
|
m_palette->addRef();
|
|
} else
|
|
m_palette = 0;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
TToonzImageP TToonzImage::clone() const { return TToonzImageP(cloneImage()); }
|
|
|
|
//---------------------------------------------------------
|
|
|
|
TToonzImage::~TToonzImage() {}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
TImage *TToonzImage::cloneImage() const { return new TToonzImage(*this); }
|
|
|
|
//=========================================================
|
|
|
|
void TToonzImage::setSubsampling(int s) { m_subsampling = s; }
|
|
|
|
//---------------------------------------------------------
|
|
|
|
void TToonzImage::setSavebox(const TRect &rect) {
|
|
QMutexLocker sl(&m_mutex);
|
|
|
|
// assert(m_lockCount>0);
|
|
assert(m_ras);
|
|
m_savebox = TRect(m_size) * rect;
|
|
assert(TRect(m_size).contains(m_savebox));
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
namespace {
|
|
|
|
//---------------------------------------------------------
|
|
// il clipRect fa riferimento alle coordinate di rasIn
|
|
// se clipRect.isEmpty() allora aggiorna tutto
|
|
|
|
/*
|
|
void doUpdateRas32(const TRaster32P &rasOut,
|
|
const TRasterCM32P &rasIn,
|
|
TPaletteP palette,
|
|
const TRect &theClipRect,
|
|
bool
|
|
transparencyCheck,
|
|
bool
|
|
applyFx)
|
|
{
|
|
assert(palette);
|
|
assert(rasIn && rasOut);
|
|
|
|
applyFx = true;
|
|
|
|
TRect clipRect(theClipRect);
|
|
if(clipRect.isEmpty())
|
|
clipRect = rasIn->getBounds();
|
|
else
|
|
{
|
|
if(!clipRect.overlaps(rasIn->getBounds())) return;
|
|
clipRect = clipRect * rasIn->getBounds();
|
|
}
|
|
if (clipRect.isEmpty())
|
|
return;
|
|
|
|
TRect clipRectIn, clipRectOut;
|
|
|
|
if (applyFx && palette->getFxRects(clipRect, clipRectIn, clipRectOut))
|
|
{
|
|
TRect rAux = clipRectIn;
|
|
TRasterP rAuxIn = rasIn->extract(clipRectIn);
|
|
if (rAux!=clipRectIn && rAux!=rasIn->getBounds())
|
|
{
|
|
TRasterCM32P rNew(rAux.getSize());
|
|
TRect tmpRect = clipRectIn - rAux.getP00();
|
|
rNew->extract(tmpRect)->copy(rAuxIn);
|
|
rAuxIn = rNew;
|
|
clipRectIn = rAux;
|
|
}
|
|
TTile tileIn(rAuxIn, convert(clipRectIn.getP00()));
|
|
|
|
rAux = clipRectOut;
|
|
TRasterP rAuxOut = rasOut->extract(clipRectOut);
|
|
TTile tileOut(rAuxOut, convert(clipRectOut.getP00()));
|
|
TRop::convert(tileOut, tileIn, palette, transparencyCheck, true);
|
|
}
|
|
else
|
|
{
|
|
TRect clipRectIn = clipRect;
|
|
TRect clipRectOut = clipRect;
|
|
TRasterP _rasOut = rasOut->extract(clipRectOut);
|
|
TRasterP _rasIn;
|
|
|
|
_rasIn = rasIn->extract(clipRectIn);
|
|
|
|
TRop::convert(TTile(_rasOut, convert(clipRectOut.getP00())),
|
|
TTile(_rasIn, convert(clipRectIn.getP00())),
|
|
palette,
|
|
transparencyCheck, false);
|
|
}
|
|
}
|
|
|
|
*/
|
|
|
|
} // anonymous namespace
|
|
|
|
//---------------------------------------------------------
|
|
/*
|
|
TRaster32P TToonzImage::getRGBM(bool readOnly, bool computeFx)
|
|
{
|
|
|
|
if (readOnly)
|
|
{
|
|
QMutexLocker sl(m_mutex);
|
|
|
|
if (m_ras32)
|
|
return m_ras32->clone();
|
|
|
|
TRasterCM32P rasCM32;
|
|
if (m_ras)
|
|
rasCM32 = m_ras;
|
|
else
|
|
rasCM32 = getCMapped(true);
|
|
|
|
assert(rasCM32);
|
|
|
|
TPalette *palette = getPalette();
|
|
assert(palette);
|
|
|
|
TRaster32P ras32(rasCM32->getSize());
|
|
const TPixel32 bgColor(255,255,255,0);
|
|
ras32->fillOutside(m_savebox, bgColor);
|
|
|
|
doUpdateRas32(ras32, rasCM32, palette, m_savebox, false, computeFx);
|
|
return ras32;
|
|
}
|
|
else
|
|
{
|
|
QMutexLocker sl(m_mutex);
|
|
return m_ras32;
|
|
}
|
|
}
|
|
*/
|
|
//---------------------------------------------------------
|
|
|
|
TRasterCM32P TToonzImage::getCMapped(/*bool readOnly*/) const {
|
|
/*
|
|
if (readOnly)
|
|
{
|
|
{
|
|
QMutexLocker sl(m_mutex);
|
|
if (m_ras)
|
|
return m_ras->clone();
|
|
}
|
|
|
|
return decompress();
|
|
}
|
|
else
|
|
*/
|
|
{
|
|
// QMutexLocker sl(&m_mutex);
|
|
return m_ras;
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
void TToonzImage::setCMapped(const TRasterCM32P &ras) {
|
|
QMutexLocker sl(&m_mutex);
|
|
m_ras = ras;
|
|
m_size = ras->getSize();
|
|
m_savebox = ras->getBounds();
|
|
// delete [] m_compressedBuffer;
|
|
// m_compressedBuffer = 0;
|
|
// m_compressedBufferSize = 0;
|
|
}
|
|
|
|
//---------------------------------------------------------
|
|
|
|
void TToonzImage::getCMapped(const TRasterCM32P &ras) {
|
|
assert(ras && ras->getSize() == m_size);
|
|
|
|
QMutexLocker sl(&m_mutex);
|
|
if (m_ras) ras->copy(m_ras);
|
|
/*
|
|
else
|
|
decompress(ras);
|
|
*/
|
|
}
|