static void
find_max (guchar *src, gint bpp, AutostretchData *data)
{
double h, s, v;
gimp_rgb_to_hsv4(src, &h, &s, &v);
if (s > data->shi) data->shi = s;
if (s < data->slo) data->slo = s;
if (v > data->vhi) data->vhi = v;
if (v < data->vlo) data->vlo = v;
}
static void
autostretch_hsv_func (guchar *src, guchar *dest, gint bpp,
AutostretchData *data)
{
double h, s, v;
gimp_rgb_to_hsv4(src, &h, &s, &v);
if (data->shi != data->slo)
s = (s - data->slo) / (data->shi - data->slo);
if (data->vhi != data->vlo)
v = (v - data->vlo) / (data->vhi - data->vlo);
gimp_hsv_to_rgb4(dest, h, s, v);
if (bpp == 4)
dest[3] = src[3];
}
static void
extract_val (const guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register const guchar *rgb_src = src;
register guchar *val_dst = dst[0];
register gint count = numpix, offset = bpp;
gdouble val, dummy;
while (count-- > 0)
{
gimp_rgb_to_hsv4 (rgb_src, &dummy, &dummy, &val);
*val_dst++ = (guchar) (val * 255.999);
rgb_src += offset;
}
}
static void
extract_hsv (const guchar *src,
gint bpp,
gint numpix,
guchar **dst)
{
register const guchar *rgb_src = src;
register guchar *hue_dst = dst[0];
register guchar *sat_dst = dst[1];
register guchar *val_dst = dst[2];
register gint count = numpix, offset = bpp;
gdouble hue, sat, val;
while (count-- > 0)
{
gimp_rgb_to_hsv4 (rgb_src, &hue, &sat, &val);
*hue_dst++ = (guchar) (hue * 255.999);
*sat_dst++ = (guchar) (sat * 255.999);
*val_dst++ = (guchar) (val * 255.999);
rgb_src += offset;
}
}
static void
color_rotate_row (const guchar *src_row,
guchar *dest_row,
gint row,
gint row_width,
gint bytes)
{
gint col, bytenum;
gdouble H, S, V;
guchar rgb[3];
for (col = 0; col < row_width; col++)
{
gboolean skip = FALSE;
rgb[0] = src_row[col * bytes + 0];
rgb[1] = src_row[col * bytes + 1];
rgb[2] = src_row[col * bytes + 2];
gimp_rgb_to_hsv4 (rgb, &H, &S, &V);
if (rcm_is_gray (S))
{
if (Current.Gray_to_from == GRAY_FROM)
{
if (rcm_angle_inside_slice (Current.Gray->hue,
Current.From->angle) <= 1)
{
H = Current.Gray->hue / TP;
S = Current.Gray->satur;
}
else
{
skip = TRUE;
}
}
else
{
skip = TRUE;
gimp_hsv_to_rgb4 (rgb, Current.Gray->hue / TP,
Current.Gray->satur, V);
}
}
if (! skip)
{
H = rcm_linear (rcm_left_end (Current.From->angle),
rcm_right_end (Current.From->angle),
rcm_left_end (Current.To->angle),
rcm_right_end (Current.To->angle),
H * TP);
H = angle_mod_2PI (H) / TP;
gimp_hsv_to_rgb4 (rgb, H, S, V);
}
dest_row[col * bytes + 0] = rgb[0];
dest_row[col * bytes + 1] = rgb[1];
dest_row[col * bytes + 2] = rgb[2];
if (bytes > 3)
{
for (bytenum = 3; bytenum < bytes; bytenum++)
dest_row[col * bytes + bytenum] = src_row[col * bytes + bytenum];
}
}
}
ReducedImage*
rcm_reduce_image (GimpDrawable *drawable,
GimpDrawable *mask,
gint LongerSize,
gint Slctn)
{
guint32 image;
GimpPixelRgn srcPR, srcMask;
ReducedImage *temp;
guchar *tempRGB, *src_row, *tempmask, *src_mask_row;
gint i, j, x1, x2, y1, y2;
gint RH, RW, width, height, bytes;
gboolean NoSelectionMade;
gint offx, offy;
gdouble *tempHSV, H, S, V;
bytes = drawable->bpp;
temp = g_new0 (ReducedImage, 1);
/* get bounds of image or selection */
gimp_drawable_mask_bounds (drawable->drawable_id, &x1, &y1, &x2, &y2);
if (((x2-x1) != drawable->width) || ((y2-y1) != drawable->height))
NoSelectionMade = FALSE;
else
NoSelectionMade = TRUE;
switch (Slctn)
{
case ENTIRE_IMAGE:
x1 = 0;
x2 = drawable->width;
y1 = 0;
y2 = drawable->height;
break;
case SELECTION_IN_CONTEXT:
x1 = MAX (0, x1 - (x2-x1) / 2.0);
x2 = MIN (drawable->width, x2 + (x2-x1) / 2.0);
y1 = MAX (0, y1 - (y2-y1) / 2.0);
y2 = MIN (drawable->height, y2 + (y2-y1) / 2.0);
break;
default:
break; /* take selection dimensions */
}
/* clamp to image size since this is the size of the mask */
gimp_drawable_offsets (drawable->drawable_id, &offx, &offy);
image = gimp_item_get_image (drawable->drawable_id);
x1 = CLAMP (x1, - offx, gimp_image_width (image) - offx);
x2 = CLAMP (x2, - offx, gimp_image_width (image) - offx);
y1 = CLAMP (y1, - offy, gimp_image_height (image) - offy);
y2 = CLAMP (y2, - offy, gimp_image_height (image) - offy);
/* calculate size of preview */
width = x2 - x1;
height = y2 - y1;
if (width < 1 || height < 1)
return temp;
if (width > height)
{
RW = LongerSize;
RH = (float) height * (float) LongerSize / (float) width;
}
else
{
RH = LongerSize;
RW = (float)width * (float) LongerSize / (float) height;
}
/* allocate memory */
tempRGB = g_new (guchar, RW * RH * bytes);
tempHSV = g_new (gdouble, RW * RH * bytes);
tempmask = g_new (guchar, RW * RH);
gimp_pixel_rgn_init (&srcPR, drawable, x1, y1, width, height, FALSE, FALSE);
gimp_pixel_rgn_init (&srcMask, mask,
x1 + offx, y1 + offy, width, height, FALSE, FALSE);
src_row = g_new (guchar, width * bytes);
src_mask_row = g_new (guchar, width * bytes);
/* reduce image */
for (i = 0; i < RH; i++)
{
gint whichcol, whichrow;
whichrow = (float)i * (float)height / (float)RH;
gimp_pixel_rgn_get_row (&srcPR, src_row, x1, y1 + whichrow, width);
gimp_pixel_rgn_get_row (&srcMask, src_mask_row,
x1 + offx, y1 + offy + whichrow, width);
for (j = 0; j < RW; j++)
{
whichcol = (float)j * (float)width / (float)RW;
if (NoSelectionMade)
tempmask[i*RW+j] = 255;
else
tempmask[i*RW+j] = src_mask_row[whichcol];
gimp_rgb_to_hsv4 (&src_row[whichcol*bytes], &H, &S, &V);
tempRGB[i*RW*bytes+j*bytes+0] = src_row[whichcol*bytes+0];
tempRGB[i*RW*bytes+j*bytes+1] = src_row[whichcol*bytes+1];
tempRGB[i*RW*bytes+j*bytes+2] = src_row[whichcol*bytes+2];
tempHSV[i*RW*bytes+j*bytes+0] = H;
tempHSV[i*RW*bytes+j*bytes+1] = S;
tempHSV[i*RW*bytes+j*bytes+2] = V;
if (bytes == 4)
tempRGB[i*RW*bytes+j*bytes+3] = src_row[whichcol*bytes+3];
}
}
/* return values */
temp->width = RW;
temp->height = RH;
temp->rgb = tempRGB;
temp->hsv = tempHSV;
temp->mask = tempmask;
return temp;
}
