static void
gimp_layer_mask_undo_pop (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
GimpLayerMaskUndo *layer_mask_undo = GIMP_LAYER_MASK_UNDO (undo);
GimpLayer *layer = GIMP_LAYER (GIMP_ITEM_UNDO (undo)->item);
GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum);
if ((undo_mode == GIMP_UNDO_MODE_UNDO &&
undo->undo_type == GIMP_UNDO_LAYER_MASK_ADD) ||
(undo_mode == GIMP_UNDO_MODE_REDO &&
undo->undo_type == GIMP_UNDO_LAYER_MASK_REMOVE))
{
/* remove layer mask */
gimp_layer_apply_mask (layer, GIMP_MASK_DISCARD, FALSE);
}
else
{
/* restore layer mask */
gimp_layer_add_mask (layer, layer_mask_undo->layer_mask, FALSE, NULL);
}
}
/* -----------------------
* p_tri_map_preprocessing
* -----------------------
* prepare the tri mask for processing
* - have bpp == 1
* - have same size and offset as the input drawable (that is a layer)
* - pixel values >= 240 are set to value 240 (MATTING_USER_FOREGROUND)
* - in case the input layer already has an alpha channel
* all fully transparent (alpha == 0) pixels are also set 0 (MATTING_USER_BACKGROUND)
* in the tri map to keep pixels fully transparent. (such pixels typicall do not
* have a useful color information in the RGB channels)
*
*
* in case the user provided the tri map as layer or channel that is NOT the layermask of the input layer
* we create a new dummy layer with same size and offset as the input layer
* and add a layermask to this dummy layer.
* The layermask of the dummy layer is then filled with the intersecting grayscale copy
* of the user-provided triMap drawable and will be used as tri map in the alpha matting processing.
*
* returns the dawable Id of the relevant TRI MAP that fulfills the conditons listed above.
*/
static gint32
p_tri_map_preprocessing (GimpDrawable *drawable, GapFgExtractValues *fgValPtr, gint32 *dummyLayerId)
{
gint32 prepocessedTriMapLayerId;
gint32 inputLayerMaskId;
gint32 imageId;
*dummyLayerId = -1;
imageId = gimp_drawable_get_image(drawable->drawable_id);
inputLayerMaskId = gimp_layer_get_mask(drawable->drawable_id);
if (fgValPtr->tri_map_drawable_id == inputLayerMaskId)
{
prepocessedTriMapLayerId = inputLayerMaskId;
}
else
{
gint offset_x;
gint offset_y;
gint32 dummyLayerMaskId;
gint32 l_fsel_layer_id;
*dummyLayerId = gimp_layer_new(imageId
, "DUMMY"
, drawable->width
, drawable->height
, GIMP_RGBA_IMAGE
, 100.0 /* full opacity */
, GIMP_NORMAL_MODE /* normal mode */
);
/* get offsets of the input drawable (layer) within the image */
gimp_drawable_offsets (drawable->drawable_id, &offset_x, &offset_y);
/* add dummy layer (of same size at same offsets) to the same image */
gimp_image_add_layer(imageId, *dummyLayerId, -1 /* stackposition */ );
gimp_layer_set_offsets(*dummyLayerId, offset_x, offset_y);
/* create a new layermask (black is full transparent */
dummyLayerMaskId = gimp_layer_create_mask(*dummyLayerId, GIMP_ADD_BLACK_MASK);
gimp_layer_add_mask(*dummyLayerId, dummyLayerMaskId);
gimp_edit_copy(fgValPtr->tri_map_drawable_id);
l_fsel_layer_id = gimp_edit_paste(dummyLayerMaskId, FALSE);
gimp_floating_sel_anchor(l_fsel_layer_id);
prepocessedTriMapLayerId = dummyLayerMaskId;
}
gap_fg_rgn_tri_map_normalize(drawable, prepocessedTriMapLayerId);
return(prepocessedTriMapLayerId);
} /* end p_tri_map_preprocessing */
static MagickBooleanType ReadOneLayer(Image* image,XCFDocInfo* inDocInfo,
XCFLayerInfo *outLayer )
{
ssize_t
i;
MagickOffsetType
offset;
unsigned int
foundPropEnd = 0;
size_t
hierarchy_offset,
layer_mask_offset;
/* clear the block! */
(void) ResetMagickMemory( outLayer, 0, sizeof( XCFLayerInfo ) );
/* read in the layer width, height, type and name */
outLayer->width = ReadBlobMSBLong(image);
outLayer->height = ReadBlobMSBLong(image);
outLayer->type = ReadBlobMSBLong(image);
(void) ReadBlobStringWithLongSize(image, outLayer->name,
sizeof(outLayer->name));
/* allocate the image for this layer */
outLayer->image=CloneImage(image,outLayer->width, outLayer->height,MagickTrue,
&image->exception);
if (outLayer->image == (Image *) NULL)
return MagickFalse;
/* read the layer properties! */
foundPropEnd = 0;
while ( (foundPropEnd == MagickFalse) && (EOFBlob(image) == MagickFalse) ) {
PropType prop_type = (PropType) ReadBlobMSBLong(image);
size_t prop_size = ReadBlobMSBLong(image);
switch (prop_type)
{
case PROP_END:
foundPropEnd = 1;
break;
case PROP_ACTIVE_LAYER:
outLayer->active = 1;
break;
case PROP_FLOATING_SELECTION:
outLayer->floating_offset = ReadBlobMSBLong(image);
break;
case PROP_OPACITY:
outLayer->opacity = ReadBlobMSBLong(image);
break;
case PROP_VISIBLE:
outLayer->visible = ReadBlobMSBLong(image);
break;
case PROP_LINKED:
outLayer->linked = ReadBlobMSBLong(image);
break;
case PROP_PRESERVE_TRANSPARENCY:
outLayer->preserve_trans = ReadBlobMSBLong(image);
break;
case PROP_APPLY_MASK:
outLayer->apply_mask = ReadBlobMSBLong(image);
break;
case PROP_EDIT_MASK:
outLayer->edit_mask = ReadBlobMSBLong(image);
break;
case PROP_SHOW_MASK:
outLayer->show_mask = ReadBlobMSBLong(image);
break;
case PROP_OFFSETS:
outLayer->offset_x = (ssize_t) ReadBlobMSBLong(image);
outLayer->offset_y = (ssize_t) ReadBlobMSBLong(image);
break;
case PROP_MODE:
outLayer->mode = ReadBlobMSBLong(image);
break;
case PROP_TATTOO:
outLayer->preserve_trans = ReadBlobMSBLong(image);
break;
case PROP_PARASITES:
{
for (i=0; i < (ssize_t) prop_size; i++ )
(void) ReadBlobByte(image);
/*
ssize_t base = info->cp;
GimpParasite *p;
while (info->cp - base < prop_size)
{
p = xcf_load_parasite(info);
gimp_drawable_parasite_attach(GIMP_DRAWABLE(layer), p);
gimp_parasite_free(p);
}
if (info->cp - base != prop_size)
g_message ("Error detected while loading a layer's parasites");
*/
}
break;
default:
/* g_message ("unexpected/unknown layer property: %d (skipping)",
prop_type); */
{
int buf[16];
ssize_t amount;
/* read over it... */
while ((prop_size > 0) && (EOFBlob(image) == MagickFalse))
{
amount = (ssize_t) MagickMin(16, prop_size);
amount = ReadBlob(image, (size_t) amount, (unsigned char *) &buf);
if (!amount)
ThrowBinaryException(CorruptImageError,"CorruptImage",
image->filename);
prop_size -= (size_t) MagickMin(16, (size_t) amount);
}
}
break;
}
}
if (foundPropEnd == MagickFalse)
return(MagickFalse);
/* clear the image based on the layer opacity */
outLayer->image->background_color.opacity=
ScaleCharToQuantum((unsigned char) (255-outLayer->opacity));
(void) SetImageBackgroundColor(outLayer->image);
/* set the compositing mode */
outLayer->image->compose = GIMPBlendModeToCompositeOperator( outLayer->mode );
if ( outLayer->visible == MagickFalse )
{
/* BOGUS: should really be separate member var! */
outLayer->image->compose = NoCompositeOp;
}
/* read the hierarchy and layer mask offsets */
hierarchy_offset = ReadBlobMSBLong(image);
layer_mask_offset = ReadBlobMSBLong(image);
/* read in the hierarchy */
offset=SeekBlob(image, (MagickOffsetType) hierarchy_offset, SEEK_SET);
if (offset < 0)
(void) ThrowMagickException(&image->exception,GetMagickModule(),
CorruptImageError,"InvalidImageHeader","`%s'",image->filename);
if (load_hierarchy (image, inDocInfo, outLayer) == 0)
return(MagickFalse);
/* read in the layer mask */
if (layer_mask_offset != 0)
{
offset=SeekBlob(image, (MagickOffsetType) layer_mask_offset, SEEK_SET);
#if 0 /* BOGUS: support layer masks! */
layer_mask = xcf_load_layer_mask (info, gimage);
if (layer_mask == 0)
goto error;
/* set the offsets of the layer_mask */
GIMP_DRAWABLE (layer_mask)->offset_x = GIMP_DRAWABLE (layer)->offset_x;
GIMP_DRAWABLE (layer_mask)->offset_y = GIMP_DRAWABLE (layer)->offset_y;
gimp_layer_add_mask (layer, layer_mask, MagickFalse);
layer->mask->apply_mask = apply_mask;
layer->mask->edit_mask = edit_mask;
layer->mask->show_mask = show_mask;
#endif
}
/* attach the floating selection... */
#if 0 /* BOGUS: we may need to read this, even if we don't support it! */
if (add_floating_sel)
{
GimpLayer *floating_sel;
floating_sel = info->floating_sel;
floating_sel_attach (floating_sel, GIMP_DRAWABLE (layer));
}
#endif
return MagickTrue;
}
static void run ( const gchar *name, gint nparams, const GimpParam *param,
gint *nreturn_vals, GimpParam **return_vals)
{
static GimpParam values[3];
GimpRunMode run_mode;
GimpPDBStatusType status = GIMP_PDB_SUCCESS;
SeparateContext mysc;
//enum separate_function func = SEP_NONE;
run_mode = param[0].data.d_int32;
/* setup for localization */
INIT_I18N ();
cmsErrorAction( LCMS_ERROR_IGNORE );
mysc.filename = NULL;
if( nparams != ( run_mode == GIMP_RUN_NONINTERACTIVE ? 2 : 1 ) )
status = GIMP_PDB_CALLING_ERROR;
else if( run_mode == GIMP_RUN_NONINTERACTIVE ) {
if( param[1].type != GIMP_PDB_STRING || strlen( param[1].data.d_string ) == 0 )
status = GIMP_PDB_CALLING_ERROR;
else
mysc.filename = g_strdup( param[1].data.d_string );
} else {
gint size = gimp_get_data_size( "plug-in-separate-import/lastpath" );
if( size ) {
mysc.filename = g_malloc( size );
gimp_get_data( "plug-in-separate-import/lastpath", mysc.filename );
}
}
if( status == GIMP_PDB_SUCCESS && ( run_mode == GIMP_RUN_NONINTERACTIVE || separate_import_dialog( &mysc ) ) ) {
gint i, j, x, y;
TIFF *in;
guint32 width, height, stripSize, stripCount, stripHeight;
gint16 bps, spp, step, planerConfig, photometric, inkset, resolutionUnit;
float xres, yres;
const gchar *layerNames[] = { "C", "M", "Y", "K" };
guchar *buf, *maskbuf[4], *srcbuf, *destbuf[4], *iccProfile;
gint32 layers[5], masks[4];
GimpDrawable *drw[4];
GimpPixelRgn rgn[4];
GimpRGB primaries[4] = { { .180, .541, .870, 1.0 },
{ .925, .149, .388, 1.0 },
{ .929, .862, .129, 1.0 },
{ 0, 0, 0, 1.0 } };
gchar *str = NULL;
gchar *baseName = g_path_get_basename( gimp_filename_to_utf8( mysc.filename ) );
#ifdef G_OS_WIN32
{
gchar *_filename = NULL; // win32 filename encoding(not UTF-8)
_filename = g_win32_locale_filename_from_utf8( mysc.filename );
in = TIFFOpen( _filename ? _filename : mysc.filename, "r" );
g_free( _filename );
}
#else
in = TIFFOpen( mysc.filename, "r" );
#endif
if( !in ) {
str = g_strdup_printf( _( "Cannot open : \"%s\"" ), baseName );
gimp_message( str );
g_free( str );
status = GIMP_PDB_EXECUTION_ERROR;
} else {
if( ( TIFFGetField( in, TIFFTAG_BITSPERSAMPLE, &bps ) == FALSE || ( bps != 8 && bps != 16 ) ) ||
( TIFFGetField( in, TIFFTAG_SAMPLESPERPIXEL, &spp ) == FALSE || spp != 4 ) ||
( TIFFGetField( in, TIFFTAG_PHOTOMETRIC, &photometric ) == FALSE || photometric != PHOTOMETRIC_SEPARATED ) ||
( TIFFGetField( in, TIFFTAG_PLANARCONFIG, &planerConfig ) == FALSE || planerConfig != PLANARCONFIG_CONTIG ) ||
( TIFFGetField( in, TIFFTAG_INKSET, &inkset ) == TRUE && inkset != INKSET_CMYK ) ) {
str = g_strdup_printf( _( "\"%s\" is unsupported." ), baseName );
gimp_message( str );
g_free( str );
status = GIMP_PDB_EXECUTION_ERROR;
} else {
stripCount = TIFFNumberOfStrips( in );
stripSize = TIFFStripSize( in );
TIFFGetField( in, TIFFTAG_IMAGEWIDTH, &width );
TIFFGetField( in, TIFFTAG_IMAGELENGTH, &height );
TIFFGetField( in, TIFFTAG_ROWSPERSTRIP, &stripHeight );
TIFFGetField( in, TIFFTAG_RESOLUTIONUNIT, &resolutionUnit );
TIFFGetField( in, TIFFTAG_XRESOLUTION, &xres );
TIFFGetField( in, TIFFTAG_YRESOLUTION, &yres );
#if 0
str = g_strdup_printf( "Photometric : %d BPS : %d SPP : %d\nInkset : %d StripCount : %d", photometric, bps, spp, inkset, stripCount );
gimp_message( str );
g_free( str );
#endif
step = ( bps == 16 ) ? 2 : 1;
buf = g_malloc( stripSize );
values[1].data.d_image = gimp_image_new( width, height, GIMP_RGB );
gimp_image_set_resolution( values[1].data.d_image, xres, yres );
gimp_context_push();
for( i = 0; i < 4; i++ ) {
layers[i] = gimp_layer_new( values[1].data.d_image, layerNames[i], width, height, GIMP_RGBA_IMAGE, 100.0, GIMP_DARKEN_ONLY_MODE );
gimp_context_set_foreground( &primaries[i] );
gimp_drawable_fill( layers[i], GIMP_FOREGROUND_FILL );
gimp_image_add_layer( values[1].data.d_image, layers[i], i );
masks[i] = gimp_layer_create_mask( layers[i], GIMP_ADD_BLACK_MASK );
gimp_layer_add_mask( layers[i], masks[i] );
drw[i] = gimp_drawable_get( masks[i] );
maskbuf[i] = g_malloc( width * stripHeight );
}
gimp_context_pop();
layers[4] = gimp_layer_new( values[1].data.d_image, _( "Background" ), width, height, GIMP_RGB_IMAGE, 100.0, GIMP_NORMAL_MODE );
gimp_drawable_fill( layers[4], GIMP_WHITE_FILL );
gimp_image_add_layer( values[1].data.d_image, layers[4], 4 );
str = g_strdup_printf( _( "Reading \"%s\"..." ), baseName );
gimp_progress_init( str );
g_free( str );
for( i = 0; i < stripCount; i++ ) {
guint32 size = TIFFReadEncodedStrip( in, i, buf, stripSize );
guint32 rowCount = ( size < stripSize ? height % stripHeight : stripHeight );
srcbuf = buf;
if( bps == 16 )
srcbuf++;
for( j = 0; j < 4; j++ ) {
gimp_pixel_rgn_init( &( rgn[j] ), drw[j],
0, stripHeight * i, width, rowCount,
FALSE, FALSE );
destbuf[j] = maskbuf[j];
}
for( y = 0; y < rowCount; y++ ) {
for( x = 0; x < width; x++ ) {
*destbuf[0]++ = *srcbuf;
srcbuf += step;
*destbuf[1]++ = *srcbuf;
srcbuf += step;
*destbuf[2]++ = *srcbuf;
srcbuf += step;
*destbuf[3]++ = *srcbuf;
srcbuf += step;
//srcbuf += spp > 4 ? spp - 4 : 0;
}
}
gimp_pixel_rgn_set_rect( &( rgn[0] ), maskbuf[0], 0, stripHeight * i, width, rowCount );
gimp_pixel_rgn_set_rect( &( rgn[1] ), maskbuf[1], 0, stripHeight * i, width, rowCount );
gimp_pixel_rgn_set_rect( &( rgn[2] ), maskbuf[2], 0, stripHeight * i, width, rowCount );
gimp_pixel_rgn_set_rect( &( rgn[3] ), maskbuf[3], 0, stripHeight * i, width, rowCount );
gimp_progress_update( (gdouble)i / stripCount );
}
g_free( buf );
for( i = 0; i < 4; i++ ) {
g_free( maskbuf[i] );
gimp_drawable_detach( drw[i] );
}
#ifdef ENABLE_COLOR_MANAGEMENT
if ( TIFFGetField( in, TIFFTAG_ICCPROFILE, &width, &iccProfile ) ) {
GimpParasite *parasite;
parasite = gimp_parasite_new( CMYKPROFILE, 0, width, iccProfile );
gimp_image_parasite_attach( values[1].data.d_image, parasite );
gimp_parasite_free( parasite );
//g_free( iccProfile ); // This causes clash on TIFFClose( in ).
}
#endif
}
TIFFClose( in );
}
g_free( baseName );
} else
status = GIMP_PDB_CANCEL;
*return_vals = values;
values[0].type = GIMP_PDB_STATUS;
values[0].data.d_status = status;
if( status == GIMP_PDB_SUCCESS ) {
*nreturn_vals = 2;
values[1].type = GIMP_PDB_IMAGE;
if( run_mode != GIMP_RUN_NONINTERACTIVE ) {
gimp_image_undo_enable( values[1].data.d_image );
gimp_display_new( values[1].data.d_image );
gimp_displays_flush();
}
gimp_set_data( "plug-in-separate-import/lastpath", mysc.filename, strlen( mysc.filename ) + 1 );
} else
*nreturn_vals = 1;
g_free( mysc.filename );
}
/* --------------------------------------------
* gap_fg_from_selection_exec_apply_run
* --------------------------------------------
* generate a tri map from the current selection by filling the shrinked
* shape with white, the expanded shape with black and the borderline
* between shrinked and expanded selection with medium gray.
* the trimap is attached as layermask to the input drawable,
* and used as input for the foreground selection via alpha matting algorithm,
* that creates a resulting layer with trimmed selection.
*
*/
gint
gap_fg_from_selection_exec_apply_run (gint32 image_id, gint32 drawable_id
, gboolean doProgress, gboolean doFlush
, GapFgSelectValues *fsValPtr)
{
GimpRGB color;
gint32 activeSelection;
gint32 shrinkedSelection;
gint32 trimap;
gboolean hadSelection;
gint rc;
rc = 0;
trimap = -1;
activeSelection = -1;
shrinkedSelection = -1;
hadSelection = FALSE;
gimp_context_push();
gimp_image_undo_group_start(image_id);
if (gimp_selection_is_empty(image_id) == TRUE)
{
if (gimp_drawable_has_alpha(drawable_id) == FALSE)
{
/* if the layer has no alpha select all */
gimp_selection_all(image_id);
}
else
{
gimp_selection_layer_alpha(drawable_id);
}
activeSelection = gimp_selection_save(image_id);
}
else
{
activeSelection = gimp_selection_save(image_id);
hadSelection = TRUE;
}
trimap = gimp_layer_get_mask(drawable_id);
if (trimap < 0)
{
/* create trimap as new layermask */
trimap = gimp_layer_create_mask(drawable_id, GIMP_ADD_BLACK_MASK);
gimp_layer_add_mask(drawable_id, trimap);
}
else
{
/* use BLACK color to fill the already existing layermask
* (note that gimp_drawable_fill is used to fill the entire mask
* regardless to the current selection)
*/
color.r = 0.0;
color.g = 0.0;
color.b = 0.0;
color.a = 1.0;
gimp_context_set_background (&color);
gimp_drawable_fill(trimap, GIMP_BACKGROUND_FILL);
}
gimp_selection_sharpen(image_id);
if (fsValPtr->innerRadius > 0)
{
gimp_selection_shrink(image_id, fsValPtr->innerRadius);
}
shrinkedSelection = gimp_selection_save(image_id);
/* use WHITE color to mark foreground regions
*/
color.r = 1.0;
color.g = 1.0;
color.b = 1.0;
color.a = 1.0;
gimp_context_set_background (&color);
gimp_edit_fill(trimap, GIMP_BACKGROUND_FILL);
gimp_selection_load(activeSelection);
gimp_selection_sharpen(image_id);
if (fsValPtr->outerRadius > 0)
{
gimp_selection_grow(image_id, fsValPtr->outerRadius);
}
gimp_selection_combine(shrinkedSelection, GIMP_CHANNEL_OP_SUBTRACT);
/* use medium GRAY to mark undefined regions
*/
color.r = 0.5;
color.g = 0.5;
color.b = 0.5;
color.a = 1.0;
gimp_context_set_background (&color);
gimp_edit_fill(trimap, GIMP_BACKGROUND_FILL);
gimp_selection_none(image_id);
/* perform the foreground selection (that creates the resulting layer) */
{
GapFgExtractValues fgExtractValues;
GapFgExtractValues *fgValPtr;
fgValPtr = &fgExtractValues;
fgValPtr->input_drawable_id = drawable_id;
fgValPtr->tri_map_drawable_id = trimap;
fgValPtr->create_result = TRUE;
fgValPtr->create_layermask = fsValPtr->create_layermask;
fgValPtr->lock_color = fsValPtr->lock_color;
fgValPtr->colordiff_threshold = fsValPtr->colordiff_threshold;
rc = gap_fg_matting_exec_apply_run (image_id, drawable_id
, doProgress, doFlush
, fgValPtr
);
}
/* restore original selection */
if (hadSelection == TRUE)
{
gimp_selection_load(activeSelection);
}
gimp_image_undo_group_end(image_id);
gimp_context_pop();
return (rc);
} /* end gap_fg_from_selection_exec_apply_run */
/* -------------------------------
* gap_drawable_foreground_extract
* -------------------------------
* perform foreground extraction.
* This is done in 3 steps INIT, EXTRACTION, DONE (e.g. cleanup)
*/
static gint32
gap_drawable_foreground_extract (GimpDrawable *drawable,
GimpDrawable *maskDrawable,
GapFgExtractValues *fgValPtr
)
{
GappMattingState *state;
gint32 resultLayerId;
gint mask_offset_x;
gint mask_offset_y;
resultLayerId = -1;
/* get mask offsets within the image
* - in case mask is a channel offsets are always 0)
* - in case mask is a layer retieve its offsets
*/
gimp_drawable_offsets (drawable->drawable_id, &mask_offset_x, &mask_offset_y);
state = gap_drawable_foreground_extract_matting_init (drawable,
mask_offset_x, mask_offset_y,
maskDrawable->width,
maskDrawable->height
);
if (state)
{
gint32 imageId;
imageId = gimp_drawable_get_image(drawable->drawable_id);
resultLayerId = gimp_layer_new(imageId
, "FG"
, drawable->width
, drawable->height
, GIMP_RGBA_IMAGE
, 100.0 /* full opacity */
, GIMP_NORMAL_MODE /* normal mode */
);
if (resultLayerId != -1)
{
GimpDrawable *resultDrawable;
resultDrawable = gimp_drawable_get(resultLayerId);
if (resultDrawable != NULL)
{
gint offset_x;
gint offset_y;
gboolean resultUpdateRequired;
resultUpdateRequired = FALSE;
/* get offsets of the input drawable (layer) within the image */
gimp_drawable_offsets (drawable->drawable_id, &offset_x, &offset_y);
/* add resulting layer (of same size at same offsets) to the same image */
gimp_image_add_layer(imageId, resultLayerId, -1 /* stackposition */ );
gimp_layer_set_offsets(resultLayerId, offset_x, offset_y);
/* perform the foreground extraction */
gap_drawable_foreground_extract_matting (maskDrawable, resultDrawable, state,
0.0 // start_percentage 0 (non-interactive shall always start rendering immediate
);
/* clean up after fg extract is done */
gap_drawable_foreground_extract_matting_done (state);
/* postprocessing */
if (fgValPtr->lock_color)
{
if(gap_debug)
{
printf("postprocessing: restore resultDrawable:%d RGB channels from original drawable:%d\n"
,(int)resultDrawable->drawable_id
,(int)drawable->drawable_id
);
}
resultUpdateRequired = TRUE;
gap_fg_rgn_copy_rgb_channels(drawable, resultDrawable);
}
if (fgValPtr->create_layermask)
{
gint32 resultLayerMaskId;
/* create a new layermask (from alpha channel) */
resultLayerMaskId = gimp_layer_create_mask(resultLayerId, GIMP_ADD_ALPHA_MASK);
gimp_layer_add_mask(resultLayerId, resultLayerMaskId);
if (gimp_drawable_has_alpha(drawable->drawable_id))
{
if(gap_debug)
{
printf("postprocessing: restore resultDrawable:%d ALPHA channel from original drawable:%d\n"
,(int)resultDrawable->drawable_id
,(int)drawable->drawable_id
);
}
/* copy the original alpha channel to the result layer */
gap_fg_rgn_copy_alpha_channel(drawable, resultDrawable);
resultUpdateRequired = TRUE;
}
}
if(resultUpdateRequired)
{
gimp_drawable_update (resultDrawable->drawable_id
, 0, 0
, resultDrawable->width, resultDrawable->height
);
}
gimp_drawable_detach (resultDrawable);
}
}
}
return (resultLayerId);
} /* end gap_drawable_foreground_extract */
