void
Drawable_set( Handle self, HV * profile)
{
dPROFILE;
if ( pexist( font))
{
SvHV_Font( pget_sv( font), &Font_buffer, "Drawable::set");
my-> set_font( self, Font_buffer);
pdelete( font);
}
if ( pexist( translate))
{
AV * av = ( AV *) SvRV( pget_sv( translate));
Point tr = {0,0};
SV ** holder = av_fetch( av, 0, 0);
if ( holder) tr.x = SvIV( *holder); else warn("RTC0059: Array panic on 'translate'");
holder = av_fetch( av, 1, 0);
if ( holder) tr.y = SvIV( *holder); else warn("RTC0059: Array panic on 'translate'");
my-> set_translate( self, tr);
pdelete( translate);
}
if ( pexist( width) && pexist( height)) {
Point size;
size. x = pget_i( width);
size. y = pget_i( height);
my-> set_size( self, size);
pdelete( width);
pdelete( height);
}
inherited set( self, profile);
}
void
Timer_update_sys_handle( Handle self, HV * profile)
{
dPROFILE;
Handle xOwner = pexist( owner) ? pget_H( owner) : var-> owner;
if (!( pexist( owner))) return;
if ( !apc_timer_create( self, xOwner, pexist( timeout)
? pget_i( timeout)
: my-> get_timeout( self)))
croak("cannot create timer");
if ( pexist( timeout)) pdelete( timeout);
}
void
Menu_update_sys_handle( Handle self, HV * profile)
{
dPROFILE;
Handle xOwner = pexist( owner) ? pget_H( owner) : var-> owner;
var-> system = true;
if ( var-> owner && ( xOwner != var-> owner))
((( PWindow) var-> owner)-> self)-> set_menu( var-> owner, nilHandle);
if ( !pexist( owner)) return;
if ( !apc_menu_create( self, xOwner))
croak("Cannot create menu");
}
void
AbstractMenu_set( Handle self, HV * profile)
{
dPROFILE;
Bool select = false;
if ( pexist( owner)) {
select = pexist( selected) ? pget_B( selected) : my-> get_selected( self);
pdelete( selected);
}
inherited set( self, profile);
if ( select) my-> set_selected( self, true);
}
void Window_set( Handle self, HV * profile)
{
dPROFILE;
Bool owner_icon = false;
if ( pexist( menuFont)) {
SvHV_Font( pget_sv( menuFont), &Font_buffer, "Window::set");
my-> set_menu_font( self, Font_buffer);
pdelete( menuFont);
}
if ( pexist( owner)) {
owner_icon = pexist( ownerIcon) ? pget_B( ownerIcon) : my-> get_ownerIcon( self);
pdelete( ownerIcon);
}
if ( pexist( frameOrigin) || pexist( frameSize)) {
Bool io = 0, is = 0;
Point o, s;
if ( pexist( frameOrigin)) {
int set[2];
prima_read_point( pget_sv( frameOrigin), set, 2, "Array panic on 'frameOrigin'");
pdelete( frameOrigin);
o. x = set[0];
o. y = set[1];
io = 1;
} else {
o.x = o. y = 0;
}
if ( pexist( frameSize)) {
int set[2];
prima_read_point( pget_sv( frameSize), set, 2, "Array panic on 'frameSize'");
pdelete( frameSize);
s. x = set[0];
s. y = set[1];
is = 1;
} else {
s.x = s. y = 0;
}
if ( is && io)
apc_widget_set_rect( self, o. x, o. y, s. x, s. y);
else if ( io)
my-> set_frameOrigin( self, o);
else
my-> set_frameSize( self, s);
}
inherited set( self, profile);
if ( owner_icon) {
my-> set_ownerIcon( self, 1);
opt_set( optOwnerIcon);
}
}
/*
FFT
profile keys: inverse => BOOL; direct or inverse transform
*/
PImage
IPA__Global_fft(PImage img,HV *profile)
{
#define METHOD "IPA::Global::fft"
dPROFILE;
Bool inverse = 0, failed = false;
PImage ret = nil;
double * buffer = nil;
if ( sizeof(double) % 2) {
warn("%s:'double' is even-sized on this platform", METHOD);
return nil;
}
if ( !img || !kind_of(( Handle) img, CImage))
croak("%s: not an image passed", METHOD);
if ( !pow2( img-> w))
croak("%s: image width is not a power of 2", METHOD);
if ( !pow2( img-> h))
croak("%s: image height is not a power of 2", METHOD);
if ( pexist( inverse)) inverse = pget_B( inverse);
/* preparing structures */
ret = ( PImage) img-> self-> dup(( Handle) img);
if ( !ret) fail( "%s: Return image allocation failed");
++SvREFCNT( SvRV( ret-> mate));
ret-> self-> set_type(( Handle) ret, imDComplex);
if ( ret-> type != imDComplex) {
warn("%s:Cannot set image to imDComplex", METHOD);
failed = 1;
goto EXIT;
}
buffer = malloc((sizeof(double) * img-> w * 2));
if ( !buffer) {
warn("%s: Error allocating %d bytes", METHOD, (int)(sizeof(double) * img-> w * 2));
failed = 1;
goto EXIT;
}
fft_2d(( double *) ret-> data, ret-> w, ret-> h, inverse ? FFT_INVERSE : FFT_DIRECT, buffer);
EXIT:
free( buffer);
if ( ret)
--SvREFCNT( SvRV( ret-> mate));
return failed ? nil : ret;
#undef METHOD
}
PImage IPA__Morphology_BWTransform(PImage img,HV *profile)
{
dPROFILE;
const char *method="IPA::Morphology::BWTransform";
PImage oimg;
unsigned char *transtbl = nil;
if ( !img || !kind_of(( Handle) img, CImage))
croak("%s: not an image passed", "IPA::Morphology::BWTransform");
if (pexist(lookup)) {
SV *tblstr=pget_sv(lookup);
if (SvPOK(tblstr)) {
STRLEN tbllen;
transtbl=SvPV(tblstr,tbllen);
if (tbllen!=512) {
croak("%s: 'lookup' is %d bytes long, must be 512",method,tbllen);
}
}
else {
croak("%s : 'lookup' is not a string",method);
}
} else {
croak("%s : 'lookup' option missed",method);
}
switch (img->type) {
case imByte:
oimg=bw8bpp_transform(method,img,transtbl,1);
break;
default:
croak("%s: support for this type of images isn't realized yet",method);
}
return oimg;
}
void
Drawable_init( Handle self, HV * profile)
{
dPROFILE;
inherited init( self, profile);
apc_gp_init( self);
var-> w = var-> h = 0;
my-> set_color ( self, pget_i ( color));
my-> set_backColor ( self, pget_i ( backColor));
my-> set_fillWinding ( self, pget_B ( fillWinding));
my-> set_fillPattern ( self, pget_sv( fillPattern));
my-> set_lineEnd ( self, pget_i ( lineEnd));
my-> set_lineJoin ( self, pget_i ( lineJoin));
my-> set_linePattern ( self, pget_sv( linePattern));
my-> set_lineWidth ( self, pget_i ( lineWidth));
my-> set_region ( self, pget_H ( region));
my-> set_rop ( self, pget_i ( rop));
my-> set_rop2 ( self, pget_i ( rop2));
my-> set_textOpaque ( self, pget_B ( textOpaque));
my-> set_textOutBaseline( self, pget_B ( textOutBaseline));
my-> set_splinePrecision( self, pget_i ( splinePrecision));
if ( pexist( translate))
{
AV * av = ( AV *) SvRV( pget_sv( translate));
Point tr = {0,0};
SV ** holder = av_fetch( av, 0, 0);
if ( holder) tr.x = SvIV( *holder); else warn("RTC0059: Array panic on 'translate'");
holder = av_fetch( av, 1, 0);
if ( holder) tr.y = SvIV( *holder); else warn("RTC0059: Array panic on 'translate'");
my-> set_translate( self, tr);
}
SvHV_Font( pget_sv( font), &Font_buffer, "Drawable::init");
my-> set_font( self, Font_buffer);
my-> set_palette( self, pget_sv( palette));
CORE_INIT_TRANSIENT(Drawable);
}
static Bool
load( PImgCodec instance, PImgLoadFileInstance fi)
{
dPROFILE;
LoadRec * l = ( LoadRec *) fi-> instance;
png_uint_32 width, height;
int obd, bit_depth, color_type, interlace_type, bpp, number_passes, pass, filter;
HV * profile;
Color background;
int alpha_opt, channels, trns_n;
Bool icon;
Handle alpha_image;
png_bytep trns_t;
png_color_16p trns_p;
if (setjmp(png_jmpbuf( l-> png_ptr)) != 0) return false;
profile = fi-> profile;
png_read_info(l->png_ptr, l->info_ptr);
png_get_IHDR(l->png_ptr, l->info_ptr, &width, &height, &bit_depth, &color_type,
&interlace_type, NULL, &filter);
obd = bit_depth;
channels = (int) png_get_channels(l->png_ptr, l->info_ptr);
icon = kind_of( fi-> object, CIcon);
switch ( bit_depth) {
case 1: case 4: case 8:
break;
case 2:
png_set_packing(l->png_ptr);
bit_depth = 4;
break;
case 16:
png_set_strip_16(l->png_ptr);
bit_depth = 8;
break;
default:
sprintf( fi-> errbuf, "Bit depth %d is not supported", bit_depth);
return false;
}
switch ( color_type) {
case PNG_COLOR_TYPE_GRAY:
bpp = bit_depth | imGrayScale;
break;
case PNG_COLOR_TYPE_PALETTE:
bpp = bit_depth;
break;
case PNG_COLOR_TYPE_RGB:
png_set_bgr(l-> png_ptr);
bpp = 24;
break;
case PNG_COLOR_TYPE_GRAY_ALPHA:
bpp = bit_depth | imGrayScale;
break;
case PNG_COLOR_TYPE_RGB_ALPHA:
png_set_bgr(l-> png_ptr);
bpp = 24;
break;
default:
sprintf( fi-> errbuf, "Unknown file color type: %d", color_type);
return false;
}
/* gamma stuff */
{
double screen_gamma = default_screen_gamma, gamma = 0.45455;
Bool has_gamma = false;
if ( pexist( screen_gamma)) {
screen_gamma = pget_f( screen_gamma);
if ( screen_gamma < PNG_GAMMA_THRESHOLD || screen_gamma > PNG_MAX_GAMMA) {
sprintf( fi-> errbuf, "Error: screen_gamma value must be within %g..%g", PNG_GAMMA_THRESHOLD, (double)PNG_MAX_GAMMA);
return false;
}
}
#ifdef PNG_gAMA_SUPPORTED
if ( pexist( gamma)) {
gamma = pget_f( gamma);
if ( gamma < PNG_GAMMA_THRESHOLD || gamma > PNG_MAX_GAMMA) {
sprintf( fi-> errbuf, "Error: gamma value must be within %g..%g", PNG_GAMMA_THRESHOLD, (double)PNG_MAX_GAMMA);
return false;
}
has_gamma = true;
} else if ( png_get_gAMA(l-> png_ptr, l-> info_ptr, &gamma)) {
has_gamma = true;
}
#endif
if ( has_gamma) png_set_gamma(l->png_ptr, screen_gamma, gamma);
}
/* alpha option */
if ( pexist( alpha)) {
char * c = pget_c( alpha);
if ( stricmp( c, "blend") == 0) alpha_opt = ALPHA_OPT_BLEND; else
if ( stricmp( c, "split") == 0) {
if ( icon)
outc("Alpha channel cannot be loaded to an Icon object")
else
alpha_opt = ALPHA_OPT_SPLIT;
} else
if ( stricmp( c, "none") == 0) alpha_opt = ALPHA_OPT_NONE; else {
snprintf( fi-> errbuf, 256, "unknown alpha option '%s'", c);
return false;
}
} else
void Window_update_sys_handle( Handle self, HV * profile)
{
dPROFILE;
var-> widgetClass = wcWindow;
if (!(
pexist( owner) ||
pexist( syncPaint) ||
pexist( taskListed) ||
pexist( borderIcons) ||
pexist( onTop) ||
pexist( borderStyle)
)) return;
if ( pexist( owner)) my-> cancel_children( self);
if ( !apc_window_create( self,
pexist( owner ) ? pget_H( owner ) : var-> owner ,
pexist( syncPaint) ? pget_B( syncPaint) : my-> get_syncPaint( self),
pexist( borderIcons) ? pget_i( borderIcons) : my-> get_borderIcons( self),
pexist( borderStyle) ? pget_i( borderStyle) : my-> get_borderStyle( self),
pexist( taskListed) ? pget_B( taskListed) : my-> get_taskListed( self),
pexist( windowState) ? pget_i( windowState) : my-> get_windowState( self),
pexist( onTop) ? pget_B( onTop) : -1, /* This is way better. I should've thought of this before! */
!( pexist( originDontCare) && pget_B( originDontCare)),
!( pexist( sizeDontCare) && pget_B( sizeDontCare))
))
croak("Cannot create window");
pdelete( borderStyle);
pdelete( borderIcons);
pdelete( syncPaint);
pdelete( taskListed);
pdelete( windowState);
pdelete( onTop);
}
PImage
IPA__Global_band_filter(PImage img,HV *profile)
{
#define METHOD "IPA::Global::band_filter"
dPROFILE;
PImage ret;
int spatial = 1, homomorph = 0, lw, failed = 0, LowPass = 0;
double MinVal = 0.0, Power = 2.0, CutOff = 20.0, Boost = 0.7;
double * data, * buffer = nil;
if ( sizeof(double) % 2) {
warn("%s:'double' is even-sized on this platform", METHOD);
return nil;
}
if ( !img || !kind_of(( Handle) img, CImage))
croak("%s: not an image passed", METHOD);
if ( pexist( spatial)) spatial = pget_i( spatial);
if ( pexist( homomorph)) homomorph = pget_i( homomorph);
if ( pexist( power)) Power = pget_f( power);
if ( pexist( cutoff)) CutOff = pget_f( cutoff);
if ( pexist( boost)) Boost = pget_f( boost);
if ( pexist( low)) LowPass = pget_i( low);
if ( homomorph && !spatial)
croak("%s:Cannot perform the homomorph equalization in the spatial domain", METHOD);
if ( LowPass && ( CutOff < 0.0000001))
croak("%s:cutoff is too small for low pass", METHOD);
if ( !spatial && (( img-> type & imCategory) != imComplexNumber))
croak("%s: not an im::DComplex image passed", METHOD);
ret = ( PImage) img-> self-> dup(( Handle) img);
if ( !ret) fail( "%s: Return image allocation failed");
++SvREFCNT( SvRV( ret-> mate));
if ( spatial) {
ret-> self-> set_type(( Handle) ret, imDComplex);
if ( ret-> type != imDComplex) {
warn("%s: Cannot convert image to im::DComplex", METHOD);
failed = 1;
goto EXIT;
}
}
data = ( double *) ret-> data;
lw = ret-> w * 2;
/* Take log of input image */
if ( homomorph) {
long i, k = ret-> w * ret-> h * 2;
MinVal = *data;
for ( i = 0; i < k; i += 2)
if ( MinVal > data[i])
MinVal = data[i];
for ( i = 0; i < k; i += 2)
data[i] = ( double) log(( double) ( 1.0 + data[i] - MinVal));
}
/* fft */
if ( spatial) {
if ( !pow2( img-> w))
croak("%s: image width is not a power of 2", METHOD);
if ( !pow2( img-> h))
croak("%s: image height is not a power of 2", METHOD);
buffer = malloc((sizeof(double) * ret-> w * 2));
if ( !buffer) {
warn("%s: Error allocating %d bytes", METHOD, (int)(sizeof(double) * img-> w * 2));
failed = 1;
goto EXIT;
}
fft_2d( data, ret-> w, ret-> h, FFT_DIRECT, buffer);
}
butterworth( data, ret-> w, ret-> h, homomorph, LowPass, Power, CutOff, Boost);
/* inverse fft */
if ( spatial) {
fft_2d( data, ret-> w, ret-> h, FFT_INVERSE, buffer);
free( buffer);
buffer = nil;
}
/* Take exp of input image */
if ( homomorph) {
long i, k = ret-> w * ret-> h * 2;
for ( i = 0; i < k; i += 2)
data[i] = ( double) ( exp( data[i]) - 1.0 + MinVal);
}
/* converting type back */
if ( spatial && ret-> self-> get_preserveType(( Handle) ret))
ret-> self-> set_type(( Handle) ret, img-> type);
EXIT:
free( buffer);
if ( ret)
--SvREFCNT( SvRV( ret-> mate));
return failed ? nil : ret;
#undef METHOD
}
