714 lines
20 KiB
C++
714 lines
20 KiB
C++
#pragma once
|
|
|
|
// STPic.h: interface for the CSTPic class.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
#include <assert.h>
|
|
|
|
#ifndef STPIC_H
|
|
#define STPIC_H
|
|
|
|
/****** SASA Picture Class Template **********************
|
|
|
|
Currently there are two types of this object
|
|
ST_RGBM - CSTPic<UC_PIXEL> - UCHAR r,g,b,m channels
|
|
ST_RGBM64 - CSTPic<US_PIXEL> - USHORT r,g,b,m channels
|
|
|
|
The CMAP RASTER pictures have to be converted to ST_RGBM or
|
|
ST_RGBM64, but the CMAP information can be used with the help
|
|
of m_raster.
|
|
|
|
m_lX,m_lY - the length of the picture in X,Y direction
|
|
m_pic - the buffer of the picture
|
|
m_ras - stores the pointer to the original RASTER picture
|
|
|
|
************************************************************/
|
|
|
|
#include "toonz4.6/udit.h"
|
|
#include "toonz4.6/raster.h"
|
|
#include "toonz4.6/pixel.h"
|
|
#include "SDef.h"
|
|
#include "SError.h"
|
|
|
|
#include "timagecache.h"
|
|
#include "trasterimage.h"
|
|
|
|
#define ISINPIC(x, y) (m_pic && x >= 0 && x < m_lX && y >= 0 && y < m_lY)
|
|
|
|
typedef enum {
|
|
ST_NIL, // EMTY
|
|
ST_RGBM, // UC_PIXEL
|
|
ST_RGBM64 // US_PIXEL
|
|
} ST_TYPE;
|
|
|
|
//! Old 4.6 picture class template (sandor fxs). There is a significant
|
|
//! modification
|
|
//! to be considered starting from Toonz 6.1 - the allocated raster is now
|
|
//! managed
|
|
//! by the image cache. Basically, when constructing one such object, the image
|
|
//! is locked
|
|
//! in the Toonz cache - and you must remember to unlock and relock it along
|
|
//! inactivity periods.
|
|
template <class P>
|
|
class CSTPic {
|
|
std::string m_cacheId;
|
|
TRasterImageP m_picP;
|
|
|
|
public:
|
|
int m_lX, m_lY;
|
|
P *m_pic;
|
|
const RASTER *m_ras;
|
|
|
|
CSTPic(void)
|
|
: m_cacheId(TImageCache::instance()->getUniqueId())
|
|
, m_lX(0)
|
|
, m_lY(0)
|
|
, m_pic(0)
|
|
, m_ras(0) {}
|
|
|
|
void nullPic() {
|
|
// if ( m_pic ) { delete [] m_pic; m_pic=0; }
|
|
unlock();
|
|
TImageCache::instance()->remove(m_cacheId);
|
|
}
|
|
|
|
//! Retrieves the raster image from the cache to work with it.
|
|
void lock() {
|
|
m_picP = TImageCache::instance()->get(m_cacheId, true);
|
|
m_pic = (P *)m_picP->getRaster()->getRawData();
|
|
}
|
|
|
|
//! Release the raster image for inactivity periods.
|
|
void unlock() {
|
|
m_picP = 0;
|
|
m_pic = 0;
|
|
}
|
|
|
|
CSTPic(const int lX, const int lY)
|
|
: // throw(SMemAllocError) :
|
|
m_cacheId(TImageCache::instance()->getUniqueId())
|
|
, m_lX(lX)
|
|
, m_lY(lY)
|
|
, m_pic(0)
|
|
, m_ras(0) {
|
|
try {
|
|
initPic();
|
|
} catch (SMemAllocError) {
|
|
null();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
CSTPic(const CSTPic<P> &sp)
|
|
: // throw(SMemAllocError) :
|
|
m_lX(sp.m_lX)
|
|
, m_lY(sp.m_lY)
|
|
, m_pic(0)
|
|
, m_ras(sp.m_ras) {
|
|
try {
|
|
initPic();
|
|
copyPic(sp);
|
|
} catch (SMemAllocError) {
|
|
null();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
~CSTPic(void) { null(); }
|
|
|
|
//! Allocates the specified raster and surrenders it to the image cache.
|
|
//!\b NOTE: The raster being initialized is LOCKED after this call.
|
|
//! You must remember to UNLOCK it when no more used.
|
|
void initPic() // throw(SMemAllocError)
|
|
{
|
|
nullPic();
|
|
if (m_lX > 0 && m_lY > 0) {
|
|
// m_pic=new P[m_lX*m_lY];
|
|
TRasterGR8P ras(m_lX * m_lY * sizeof(P), 1);
|
|
if (!ras) throw SMemAllocError("in initPic");
|
|
TImageCache::instance()->add(m_cacheId, TRasterImageP(ras));
|
|
lock();
|
|
} else {
|
|
char s[200];
|
|
sprintf(s, "in initPic lXY=(%d,%d)\n", m_lX, m_lY);
|
|
throw SMemAllocError(s);
|
|
}
|
|
}
|
|
|
|
void null() {
|
|
nullPic();
|
|
m_lX = m_lY = 0;
|
|
m_ras = 0;
|
|
}
|
|
|
|
// Draws the border of the CSTPic
|
|
void drawRect(const P &ip) {
|
|
SRECT rect = {0, 0, m_lX - 1, m_lY - 1};
|
|
drawRect(rect, ip);
|
|
}
|
|
|
|
//------------------- The following need to be *LOCKED* before the call
|
|
//------------------
|
|
|
|
// Currently there are two types of STPic
|
|
// ST_RGBM - UCHAR r,g,b,m channels
|
|
// ST_RGBM64 - USHORT r,g,b,m channels
|
|
ST_TYPE getType() const {
|
|
if (!m_pic) return ST_NIL;
|
|
if (sizeof(m_pic->r) == sizeof(UCHAR)) return ST_RGBM;
|
|
if (sizeof(m_pic->r) == sizeof(USHORT)) return ST_RGBM64;
|
|
return ST_NIL;
|
|
}
|
|
|
|
// Copies the 'sp' CSTPic into 'm_pic'
|
|
|
|
void copyPic(const CSTPic<P> &sp) {
|
|
P p;
|
|
for (int y = 0; y < m_lY && y < sp.m_lY; y++)
|
|
for (int x = 0; x < m_lX && x < sp.m_lX; x++) {
|
|
sp.getPixel(x, y, p);
|
|
setRGBM(x, y, p);
|
|
}
|
|
}
|
|
|
|
// Copies the 'r' rectangle of 'sp' CSTPic into the 'p' position
|
|
// of 'm_pic'
|
|
void copyPic(const CSTPic<P> &sp, const SRECT &r, const SPOINT &p) {
|
|
P ip;
|
|
int xs, ys, xd, yd;
|
|
for (ys = r.y0, yd = p.y; ys <= r.y1; ys++, yd++)
|
|
for (xs = r.x0, xd = p.x; xs <= r.x1; xs++, xd++) {
|
|
sp.getPixel(xs, ys, ip);
|
|
setRGBM(xd, yd, ip);
|
|
}
|
|
}
|
|
|
|
// Draws a rectangle into CSTPic
|
|
void drawRect(const SRECT &rect, const P &ip) {
|
|
for (int x = rect.x0; x <= rect.x1; x++) {
|
|
setRGBM(x, rect.y0, ip);
|
|
setRGBM(x, rect.y1, ip);
|
|
}
|
|
for (int y = rect.y0; y <= rect.y1; y++) {
|
|
setRGBM(rect.x0, y, ip);
|
|
setRGBM(rect.x1, y, ip);
|
|
}
|
|
}
|
|
|
|
void erease() {
|
|
P p = {0, 0, 0, 0};
|
|
fill(p);
|
|
}
|
|
|
|
void fill(const P &ip) {
|
|
for (int y = 0; y < m_lY; y++)
|
|
for (int x = 0; x < m_lX; x++) setRGBM(x, y, ip);
|
|
}
|
|
|
|
// Checks whether (x,y) is a proper coordinate
|
|
inline bool isInPic(const int x, const int y) const {
|
|
return (m_pic && x >= 0 && x < m_lX && y >= 0 && y < m_lY);
|
|
}
|
|
|
|
// Sets the color of the CSTPic pixel
|
|
void setRGB(const int x, const int y, const P &ip) {
|
|
if (ISINPIC(x, y)) {
|
|
P *p = m_pic + y * m_lX + x;
|
|
p->r = ip.r;
|
|
p->g = ip.g;
|
|
p->b = ip.b;
|
|
}
|
|
}
|
|
|
|
void setRGBM(const int x, const int y, const P &ip) {
|
|
if (ISINPIC(x, y)) {
|
|
P *p = m_pic + y * m_lX + x;
|
|
p->r = ip.r;
|
|
p->g = ip.g;
|
|
p->b = ip.b;
|
|
p->m = ip.m;
|
|
}
|
|
}
|
|
|
|
// Sets the color of the CSTPic pixel
|
|
void setRGB(const int x, const int y, const I_PIXEL &ip) {
|
|
if (ISINPIC(x, y)) {
|
|
P *p = m_pic + y * m_lX + x;
|
|
if (getType() == ST_RGBM) {
|
|
p->r = (UCHAR)I_CUT_0_255(ip.r);
|
|
p->g = (UCHAR)I_CUT_0_255(ip.g);
|
|
p->b = (UCHAR)I_CUT_0_255(ip.b);
|
|
} else if (getType() == ST_RGBM64) {
|
|
p->r = (USHORT)I_CUT_0_65535(ip.r);
|
|
p->g = (USHORT)I_CUT_0_65535(ip.g);
|
|
p->b = (USHORT)I_CUT_0_65535(ip.b);
|
|
}
|
|
}
|
|
}
|
|
|
|
void setRGBM(const int x, const int y, const I_PIXEL &ip) {
|
|
if (ISINPIC(x, y)) {
|
|
P *p = m_pic + y * m_lX + x;
|
|
if (getType() == ST_RGBM) {
|
|
p->r = (UCHAR)I_CUT_0_255(ip.r);
|
|
p->g = (UCHAR)I_CUT_0_255(ip.g);
|
|
p->b = (UCHAR)I_CUT_0_255(ip.b);
|
|
p->m = (UCHAR)I_CUT_0_255(ip.m);
|
|
} else if (getType() == ST_RGBM64) {
|
|
p->r = I_CUT_0_65535(ip.r);
|
|
p->g = I_CUT_0_65535(ip.g);
|
|
p->b = I_CUT_0_65535(ip.b);
|
|
p->m = I_CUT_0_65535(ip.m);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Gets the color of the CSTPic pixel
|
|
void getPixel(const int x, const int y, P &ip) const {
|
|
if (ISINPIC(x, y)) {
|
|
const P *p = m_pic + y * m_lX + x;
|
|
ASSIGN_PIXEL(&ip, p);
|
|
return;
|
|
}
|
|
ip.r = ip.g = ip.b = ip.m = 0;
|
|
}
|
|
|
|
void getPixel(const int x, const int y, I_PIXEL &ip) const {
|
|
if (ISINPIC(x, y)) {
|
|
const P *p = m_pic + y * m_lX + x;
|
|
ip.r = (int)p->r;
|
|
ip.g = (int)p->g;
|
|
ip.b = (int)p->b;
|
|
ip.m = (int)p->m;
|
|
return;
|
|
}
|
|
ip.r = ip.g = ip.b = ip.m = 0;
|
|
}
|
|
|
|
// Gets the color of a RASTER pixel
|
|
// RASTER operation always gets I_PIXEL color and I_PIXEL is casted
|
|
// to the right type
|
|
void getRasterPixel(const RASTER *ras, const int x, const int y,
|
|
I_PIXEL &ip) const {
|
|
if (x >= 0 && x < ras->lx && y >= 0 && y < ras->ly && ras->buffer) {
|
|
LPIXEL *pL;
|
|
LPIXEL pLL;
|
|
SPIXEL *pS;
|
|
UD44_CMAPINDEX32 *ci32;
|
|
// UD44_PIXEL32* pen;
|
|
UD44_PIXEL32 *col;
|
|
switch (ras->type) {
|
|
case (RAS_RGBM):
|
|
pL = (LPIXEL *)(ras->buffer) + y * ras->wrap + x;
|
|
ip.r = (int)pL->r;
|
|
ip.g = (int)pL->g;
|
|
ip.b = (int)pL->b;
|
|
ip.m = (int)pL->m;
|
|
break;
|
|
case (RAS_RGBM64):
|
|
pS = (SPIXEL *)(ras->buffer) + y * ras->wrap + x;
|
|
ip.r = (int)pS->r;
|
|
ip.g = (int)pS->g;
|
|
ip.b = (int)pS->b;
|
|
ip.m = (int)pS->m;
|
|
break;
|
|
case (RAS_CM32):
|
|
ci32 = (UD44_CMAPINDEX32 *)(ras->buffer) + y * ras->wrap + x;
|
|
col = (UD44_PIXEL32 *)(ras->cmap.buffer);
|
|
PIX_CM32_MAP_TO_RGBM(*ci32, col, pLL)
|
|
ip.r = (int)pLL.r;
|
|
ip.g = (int)pLL.g;
|
|
ip.b = (int)pLL.b;
|
|
ip.m = (int)pLL.m;
|
|
break;
|
|
}
|
|
} else
|
|
ip.r = ip.g = ip.b = ip.m = 0;
|
|
}
|
|
|
|
void getRasterPixel(const int x, const int y, I_PIXEL &ip) const {
|
|
if (m_ras)
|
|
getRasterPixel(m_ras, x, y, ip);
|
|
else
|
|
ip.r = ip.g = ip.b = ip.m = 0;
|
|
}
|
|
|
|
// Sets the color of a RASTER pixel
|
|
// RASTER operation always gets I_PIXEL color and I_PIXEL is casted
|
|
// to the right type
|
|
|
|
void setRasterPixel(RASTER *ras, const int x, const int y,
|
|
const I_PIXEL &ip) const {
|
|
if (x >= 0 && x < ras->lx && y >= 0 && y < ras->ly && ras->buffer) {
|
|
LPIXEL *pL;
|
|
SPIXEL *pS;
|
|
switch (ras->type) {
|
|
case (RAS_RGBM):
|
|
pL = (LPIXEL *)(ras->buffer) + y * ras->wrap + x;
|
|
pL->r = (UCHAR)ip.r;
|
|
pL->g = (UCHAR)ip.g;
|
|
pL->b = (UCHAR)ip.b;
|
|
pL->m = (UCHAR)ip.m;
|
|
break;
|
|
case (RAS_RGBM64):
|
|
pS = (SPIXEL *)(ras->buffer) + y * ras->wrap + x;
|
|
pS->r = (USHORT)ip.r;
|
|
pS->g = (USHORT)ip.g;
|
|
pS->b = (USHORT)ip.b;
|
|
pS->m = (USHORT)ip.m;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool copy_raster(const RASTER *ir, RASTER *out_r, const int xBeg,
|
|
const int yBeg, const int xEnd, const int yEnd, const int ox,
|
|
const int oy)
|
|
|
|
{
|
|
if ((ir->lx <= 0) || (ir->ly <= 0) || (out_r->lx <= 0) || (out_r->ly <= 0))
|
|
return false;
|
|
if (ir->buffer == NULL || out_r->buffer == NULL) return false;
|
|
if (out_r->type == RAS_CM32) return false;
|
|
if (ir->type == RAS_CM32 && (ir->cmap.buffer == NULL)) return false;
|
|
|
|
for (int y = yBeg, yy = oy; y <= yEnd; y++, yy++)
|
|
for (int x = xBeg, xx = ox; x <= xEnd; x++, xx++) {
|
|
I_PIXEL ip;
|
|
getRasterPixel(ir, x, y, ip);
|
|
if (xx >= 0 && yy >= 0 && xx < out_r->lx && yy < out_r->ly) {
|
|
LPIXEL *pL;
|
|
SPIXEL *pS;
|
|
if (out_r->type == RAS_RGBM &&
|
|
(ir->type == RAS_RGBM || ir->type == RAS_CM32)) {
|
|
pL = (LPIXEL *)(out_r->buffer) + yy * out_r->wrap + xx;
|
|
pL->r = (UCHAR)ip.r;
|
|
pL->g = (UCHAR)ip.g;
|
|
pL->b = (UCHAR)ip.b;
|
|
pL->m = (UCHAR)ip.m;
|
|
} else if (out_r->type == RAS_RGBM && ir->type == RAS_RGBM64) {
|
|
pL = (LPIXEL *)(out_r->buffer) + yy * out_r->wrap + xx;
|
|
pL->r = PIX_BYTE_FROM_USHORT((USHORT)ip.r);
|
|
pL->g = PIX_BYTE_FROM_USHORT((USHORT)ip.g);
|
|
pL->b = PIX_BYTE_FROM_USHORT((USHORT)ip.b);
|
|
pL->m = PIX_BYTE_FROM_USHORT((USHORT)ip.m);
|
|
} else if (out_r->type == RAS_RGBM64 &&
|
|
(ir->type == RAS_RGBM || ir->type == RAS_CM32)) {
|
|
pS = (SPIXEL *)(out_r->buffer) + yy * out_r->wrap + xx;
|
|
pS->r = PIX_USHORT_FROM_BYTE((UCHAR)ip.r);
|
|
pS->g = PIX_USHORT_FROM_BYTE((UCHAR)ip.g);
|
|
pS->b = PIX_USHORT_FROM_BYTE((UCHAR)ip.b);
|
|
pS->m = PIX_USHORT_FROM_BYTE((UCHAR)ip.m);
|
|
} else if (out_r->type == RAS_RGBM64 && ir->type == RAS_RGBM64) {
|
|
pS = (SPIXEL *)(out_r->buffer) + yy * out_r->wrap + xx;
|
|
pS->r = (USHORT)ip.r;
|
|
pS->g = (USHORT)ip.g;
|
|
pS->b = (USHORT)ip.b;
|
|
pS->m = (USHORT)ip.m;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Generates and reads the CSTPic using RASTER.
|
|
// \b NOTE: This LOCKS the raster being read. You must remember to unlock it
|
|
// afterwards
|
|
// when it is needed no more.
|
|
virtual void read(const RASTER *ras) // throw(SMemAllocError)
|
|
{
|
|
try {
|
|
null();
|
|
if (((ras->type == RAS_RGBM || ras->type == RAS_RGBM64) && ras->buffer &&
|
|
ras->lx > 0 && ras->ly > 0) ||
|
|
(ras->type == RAS_CM32 && ras->buffer && ras->cmap.buffer &&
|
|
ras->lx > 0 && ras->ly > 0)) {
|
|
m_lX = ras->lx;
|
|
m_lY = ras->ly;
|
|
m_ras = ras;
|
|
initPic();
|
|
lock();
|
|
ST_TYPE type = getType();
|
|
P *p = m_pic;
|
|
I_PIXEL ip;
|
|
memset(&ip, 0, sizeof(I_PIXEL));
|
|
for (int y = 0; y < m_lY; y++)
|
|
for (int x = 0; x < m_lX; x++, p++) {
|
|
getRasterPixel(ras, x, y, ip);
|
|
switch (type) {
|
|
case (ST_RGBM):
|
|
if (ras->type == RAS_RGBM64) {
|
|
// RGBM have to be 'scaled' from USHORT to UCHAR
|
|
p->r = PIX_BYTE_FROM_USHORT((USHORT)ip.r);
|
|
p->g = PIX_BYTE_FROM_USHORT((USHORT)ip.g);
|
|
p->b = PIX_BYTE_FROM_USHORT((USHORT)ip.b);
|
|
p->m = PIX_BYTE_FROM_USHORT((USHORT)ip.m);
|
|
} else {
|
|
// RGBM are UCHAR in the raster
|
|
p->r = (UCHAR)ip.r;
|
|
p->g = (UCHAR)ip.g;
|
|
p->b = (UCHAR)ip.b;
|
|
p->m = (UCHAR)ip.m;
|
|
}
|
|
break;
|
|
case (ST_RGBM64):
|
|
if (ras->type == RAS_RGBM64) {
|
|
// RGBM are USHORT in the raster
|
|
p->r = ip.r;
|
|
p->g = ip.g;
|
|
p->b = ip.b;
|
|
p->m = ip.m;
|
|
} else {
|
|
// RGBM have to be 'scaled' from UCHAR to USHORT
|
|
p->r = PIX_USHORT_FROM_BYTE((UCHAR)ip.r);
|
|
p->g = PIX_USHORT_FROM_BYTE((UCHAR)ip.g);
|
|
p->b = PIX_USHORT_FROM_BYTE((UCHAR)ip.b);
|
|
p->m = PIX_USHORT_FROM_BYTE((UCHAR)ip.m);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
} catch (SMemAllocError) {
|
|
null();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
const CSTPic<P> &operator=(const CSTPic<P> &sp) // throw(SMemAllocError)
|
|
{
|
|
try {
|
|
null();
|
|
m_lX = sp.m_lX;
|
|
m_lY = sp.m_lY;
|
|
m_ras = sp.m_ras;
|
|
initPic();
|
|
copyPic(sp);
|
|
} catch (SMemAllocError) {
|
|
null();
|
|
throw;
|
|
}
|
|
|
|
return (*this);
|
|
}
|
|
|
|
// Writes the CSTPic into the RASTER
|
|
virtual void write(RASTER *ras) const // throw(SWriteRasterError)
|
|
{
|
|
if ((ras->type == RAS_RGBM || ras->type == RAS_RGBM64) && ras->lx > 0 &&
|
|
ras->ly > 0 && ras->buffer) {
|
|
int x, y;
|
|
I_PIXEL ip;
|
|
const P *p;
|
|
for (y = 0; y < m_lY && y < ras->ly; y++)
|
|
for (x = 0; x < m_lX && x < ras->lx; x++) {
|
|
p = m_pic + y * m_lX + x;
|
|
ip.r = (int)p->r;
|
|
ip.g = (int)p->g;
|
|
ip.b = (int)p->b;
|
|
ip.m = (int)p->m;
|
|
setRasterPixel(ras, x, y, ip);
|
|
}
|
|
} else
|
|
throw SWriteRasterError("(bad Raster type)");
|
|
}
|
|
|
|
// Writes the 'r' rectangle of CSTPic into the 'p' position in RASTER
|
|
virtual void write(RASTER *ras, const SRECT &r, const SPOINT &p) const
|
|
// throw(SWriteRasterError)
|
|
{
|
|
if (ras->type == RAS_RGBM || ras->type == RAS_RGBM64) {
|
|
int xs, ys, xd, yd;
|
|
P pp;
|
|
I_PIXEL ip;
|
|
for (ys = r.y0, yd = p.y; ys <= r.y1; ys++, yd++)
|
|
for (xs = r.x0, xd = p.x; xs <= r.x1; xs++, xd++) {
|
|
getPixel(xs, ys, pp);
|
|
ip.r = (int)pp.r;
|
|
ip.g = (int)pp.g;
|
|
ip.b = (int)pp.b;
|
|
ip.m = (int)pp.m;
|
|
setRasterPixel(ras, xd, yd, ip);
|
|
}
|
|
} else
|
|
throw SWriteRasterError("(bad Raster type)");
|
|
}
|
|
|
|
virtual void writeOutBorder(const RASTER *rasin, const int border,
|
|
RASTER *ras, const SRECT &r,
|
|
const SPOINT &p) const
|
|
// throw(SWriteRasterError)
|
|
{
|
|
assert(rasin->type == RAS_CM32);
|
|
UD44_PIXEL32 *col = (UD44_PIXEL32 *)(rasin->cmap.buffer);
|
|
|
|
if (ras->type == RAS_RGBM || ras->type == RAS_RGBM64) {
|
|
int xs, ys, xd, yd;
|
|
|
|
I_PIXEL ip;
|
|
for (ys = r.y0, yd = p.y; ys <= r.y1; ys++, yd++)
|
|
for (xs = r.x0, xd = p.x; xs <= r.x1; xs++, xd++) {
|
|
int x = xd - border;
|
|
int y = yd - border;
|
|
if (x >= 0 && y >= 0 && x < rasin->lx && y < rasin->ly) {
|
|
UD44_CMAPINDEX32 pixel =
|
|
*(((UD44_CMAPINDEX32 *)rasin->buffer) + y * rasin->wrap + x);
|
|
// int tone = (pix&0xff);
|
|
// int paint = ((pix>>8)&0xfff);
|
|
if ((pixel & 0xff) == 0 || ((pixel >> 8) & 0xfff) != 0) {
|
|
LPIXEL pLL;
|
|
PIX_CM32_MAP_TO_RGBM(pixel, col, pLL)
|
|
ip.r = (int)pLL.r;
|
|
ip.g = (int)pLL.g;
|
|
ip.b = (int)pLL.b;
|
|
ip.m = (int)pLL.m;
|
|
setRasterPixel(ras, xd, yd, ip);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
P pp;
|
|
getPixel(xs, ys, pp);
|
|
ip.r = (int)pp.r;
|
|
ip.g = (int)pp.g;
|
|
ip.b = (int)pp.b;
|
|
ip.m = (int)pp.m;
|
|
setRasterPixel(ras, xd, yd, ip);
|
|
}
|
|
} else
|
|
throw SWriteRasterError("(bad Raster type)");
|
|
}
|
|
|
|
void convertToCurrentType(P &d, const I_PIXEL &s) const {
|
|
if (getType() == ST_RGBM) {
|
|
d.r = (UCHAR)s.r;
|
|
d.g = (UCHAR)s.g;
|
|
d.b = (UCHAR)s.b;
|
|
d.m = (UCHAR)s.m;
|
|
}
|
|
if (getType() == ST_RGBM64) {
|
|
d.r = (USHORT)s.r;
|
|
d.g = (USHORT)s.g;
|
|
d.b = (USHORT)s.b;
|
|
d.m = (USHORT)s.m;
|
|
}
|
|
}
|
|
|
|
bool isSameColor(const P *a, const P *b) const {
|
|
if (a->r == b->r && a->g == b->g && a->b == b->b) return true;
|
|
return false;
|
|
}
|
|
|
|
void colorNoise(const I_PIXEL &cc1, const I_PIXEL &cc2, const double d) {
|
|
P c1, c2;
|
|
|
|
if (d <= 0) return;
|
|
|
|
convertToCurrentType(c1, cc1);
|
|
convertToCurrentType(c2, cc2);
|
|
int xy = m_lX * m_lY;
|
|
P *pPic = m_pic;
|
|
for (int i = 0; i < xy; i++, pPic++)
|
|
if (isSameColor(&c1, pPic)) {
|
|
double q = (rand() % 101) / 100.0;
|
|
q = d * q;
|
|
q = q > 1.0 ? 1.0 : q;
|
|
double r = (1.0 - q) * (double)c1.r + q * (double)c2.r;
|
|
double g = (1.0 - q) * (double)c1.g + q * (double)c2.g;
|
|
double b = (1.0 - q) * (double)c1.b + q * (double)c2.b;
|
|
r = D_CUT_0_255(r);
|
|
g = D_CUT_0_255(g);
|
|
b = D_CUT_0_255(b);
|
|
pPic->r = UC_ROUND(r);
|
|
pPic->g = UC_ROUND(g);
|
|
pPic->b = UC_ROUND(b);
|
|
}
|
|
}
|
|
|
|
/*
|
|
void hlsNoise(const double d)
|
|
{ int xy=m_lX*m_lY;
|
|
P* p=m_pic;
|
|
for( int i=0; i<xy; i++,p++ )
|
|
if ( p->m>0 ) {
|
|
double h,l,s,q;
|
|
rgb2hls(p->r,p->g,p->b,&h,&l,&s);
|
|
q=1.0-d*(double)((rand()%201)-100)/100.0;
|
|
l*=q;
|
|
hls2rgb(h,l,s,&(p->r),&(p->g),&(p->b));
|
|
}
|
|
}
|
|
*/
|
|
|
|
void rgb2hls(UCHAR r, UCHAR g, UCHAR b, double *h, double *l, double *s) {
|
|
double ma, mi, delta, sum;
|
|
double rf, gf, bf;
|
|
|
|
rf = (double)r / 255.0;
|
|
gf = (double)g / 255.0;
|
|
bf = (double)b / 255.0;
|
|
|
|
ma = rf > gf ? rf : gf;
|
|
ma = ma > bf ? ma : bf;
|
|
mi = rf < gf ? rf : gf;
|
|
mi = mi < bf ? mi : bf;
|
|
sum = ma + mi;
|
|
delta = ma - mi;
|
|
*l = sum / 2.0;
|
|
if (fabs(delta) < 0.000001) {
|
|
*s = 0.0;
|
|
*h = UNDEFINED;
|
|
} else {
|
|
*s = *l <= 0.5 ? delta / sum : delta / (2.0 - sum);
|
|
*h = fabs((rf - ma)) < 0.000001
|
|
? (gf - bf) / delta
|
|
: (fabs((gf - ma)) < 0.000001 ? 2.0 + (bf - rf) / delta
|
|
: 4.0 + (rf - gf) / delta);
|
|
*h *= 60;
|
|
*h = *h < 0.0 ? *h + 360.0 : *h;
|
|
}
|
|
}
|
|
|
|
double fromHue(double n1, double n2, double hue) {
|
|
double v, h;
|
|
|
|
h = hue > 360.0 ? hue - 360.0 : hue;
|
|
h = h < 0.0 ? h + 360.0 : h;
|
|
|
|
if (h < 60.0) {
|
|
v = n1 + (n2 - n1) * h / 60.0;
|
|
} else if (h < 180.0) {
|
|
v = n2;
|
|
} else if (h < 240.0) {
|
|
v = n1 + (n2 - n1) * (240.0 - h) / 60.0;
|
|
} else
|
|
v = n1;
|
|
return (v);
|
|
}
|
|
|
|
void hls2rgb(double h, double l, double s, UCHAR *r, UCHAR *g, UCHAR *b) {
|
|
double rf, gf, bf;
|
|
double m1, m2;
|
|
|
|
m2 = l <= 0.5 ? l * (1.0 + s) : l + s - l * s;
|
|
m1 = 2 * l - m2;
|
|
if (fabs(s - 0.0) < 0.000001) {
|
|
if (fabs(h - UNDEFINED) < 0.000001) {
|
|
rf = gf = bf = l * 255.0;
|
|
} else
|
|
rf = gf = bf = 0.0;
|
|
} else {
|
|
rf = fromHue(m1, m2, h + 120.0) * 255.0;
|
|
gf = fromHue(m1, m2, h) * 255.0;
|
|
bf = fromHue(m1, m2, h - 120.0) * 255.0;
|
|
}
|
|
rf = D_CUT_0_255(rf);
|
|
gf = D_CUT_0_255(gf);
|
|
bf = D_CUT_0_255(bf);
|
|
*r = UC_ROUND(rf);
|
|
*g = UC_ROUND(gf);
|
|
*b = UC_ROUND(bf);
|
|
}
|
|
};
|
|
#endif // !defined(AFX_STPIC_H__BABE9488_F054_11D5_B927_0040F674BE6A__INCLUDED_)
|