static gboolean
gimp_operation_posterize_process (GeglOperation *operation,
void *in_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi,
gint level)
{
GimpOperationPointFilter *point = GIMP_OPERATION_POINT_FILTER (operation);
GimpPosterizeConfig *config = GIMP_POSTERIZE_CONFIG (point->config);
gfloat *src = in_buf;
gfloat *dest = out_buf;
gfloat levels;
if (! config)
return FALSE;
levels = config->levels - 1.0;
while (samples--)
{
dest[RED] = RINT (src[RED] * levels) / levels;
dest[GREEN] = RINT (src[GREEN] * levels) / levels;
dest[BLUE] = RINT (src[BLUE] * levels) / levels;
dest[ALPHA] = src[ALPHA];
src += 4;
dest += 4;
}
return TRUE;
}
static void
compute_preview_rectangle (gint * xp, gint * yp, gint * wid, gint * heig)
{
gdouble x, y, w, h;
if (width >= height)
{
w = (PREVIEW_WIDTH - 50.0);
h = (gdouble) height *(w / (gdouble) width);
x = (PREVIEW_WIDTH - w) / 2.0;
y = (PREVIEW_HEIGHT - h) / 2.0;
}
else
{
h = (PREVIEW_HEIGHT - 50.0);
w = (gdouble) width *(h / (gdouble) height);
x = (PREVIEW_WIDTH - w) / 2.0;
y = (PREVIEW_HEIGHT - h) / 2.0;
}
*xp = RINT (x);
*yp = RINT (y);
*wid = RINT (w);
*heig = RINT (h);
}
static gboolean
gimp_operation_posterize_process (GeglOperation *operation,
void *in_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi,
gint level)
{
GimpOperationPosterize *posterize = GIMP_OPERATION_POSTERIZE (operation);
gfloat *src = in_buf;
gfloat *dest = out_buf;
gfloat levels;
levels = posterize->levels - 1.0;
while (samples--)
{
dest[RED] = RINT (src[RED] * levels) / levels;
dest[GREEN] = RINT (src[GREEN] * levels) / levels;
dest[BLUE] = RINT (src[BLUE] * levels) / levels;
dest[ALPHA] = RINT (src[ALPHA] * levels) / levels;
src += 4;
dest += 4;
}
return TRUE;
}
static void
offset_response (GtkWidget *widget,
gint response_id,
OffsetDialog *dialog)
{
if (response_id == GTK_RESPONSE_OK)
{
GimpImage *image = dialog->image;
if (image)
{
GimpDrawable *drawable = gimp_image_get_active_drawable (image);
gint offset_x;
gint offset_y;
offset_x =
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (dialog->off_se),
0));
offset_y =
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (dialog->off_se),
1));
gimp_drawable_offset (drawable,
dialog->context,
dialog->fill_type & WRAP_AROUND ? TRUE : FALSE,
dialog->fill_type & FILL_MASK,
offset_x, offset_y);
gimp_image_flush (image);
}
}
gtk_widget_destroy (dialog->dialog);
}
static void
update_values (void)
{
GtkWidget *entry;
entry = g_object_get_data (G_OBJECT (main_dialog), "width");
grid_cfg.hwidth =
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 0));
grid_cfg.vwidth =
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 1));
grid_cfg.iwidth =
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 2));
entry = g_object_get_data (G_OBJECT (main_dialog), "space");
grid_cfg.hspace =
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 0));
grid_cfg.vspace =
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 1));
grid_cfg.ispace =
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 2));
entry = g_object_get_data (G_OBJECT (main_dialog), "offset");
grid_cfg.hoffset =
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 0));
grid_cfg.voffset =
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 1));
grid_cfg.ioffset =
RINT (gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (entry), 2));
}
GimpTempBuf *
gimp_drawable_get_sub_preview (GimpDrawable *drawable,
gint src_x,
gint src_y,
gint src_width,
gint src_height,
gint dest_width,
gint dest_height)
{
GimpItem *item;
GimpImage *image;
GeglBuffer *buffer;
GimpTempBuf *preview;
gdouble scale;
gint scaled_x;
gint scaled_y;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (src_x >= 0, NULL);
g_return_val_if_fail (src_y >= 0, NULL);
g_return_val_if_fail (src_width > 0, NULL);
g_return_val_if_fail (src_height > 0, NULL);
g_return_val_if_fail (dest_width > 0, NULL);
g_return_val_if_fail (dest_height > 0, NULL);
item = GIMP_ITEM (drawable);
g_return_val_if_fail ((src_x + src_width) <= gimp_item_get_width (item), NULL);
g_return_val_if_fail ((src_y + src_height) <= gimp_item_get_height (item), NULL);
image = gimp_item_get_image (item);
if (! image->gimp->config->layer_previews)
return NULL;
buffer = gimp_drawable_get_buffer (drawable);
preview = gimp_temp_buf_new (dest_width, dest_height,
gimp_drawable_get_preview_format (drawable));
scale = MIN ((gdouble) dest_width / (gdouble) src_width,
(gdouble) dest_height / (gdouble) src_height);
scaled_x = RINT ((gdouble) src_x * scale);
scaled_y = RINT ((gdouble) src_y * scale);
gegl_buffer_get (buffer,
GEGL_RECTANGLE (scaled_x, scaled_y, dest_width, dest_height),
scale,
gimp_temp_buf_get_format (preview),
gimp_temp_buf_get_data (preview),
GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_CLAMP);
return preview;
}
static gboolean process (GeglOperation *operation,
void *in_buf,
void *out_buf,
glong samples,
const GeglRectangle *roi,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
gfloat *src = in_buf;
gfloat *dest = out_buf;
gfloat levels = o->levels;
while (samples--)
{
gint i;
for (i=0; i < 3; i++)
dest[i] = RINT (src[i] * levels) / levels;
dest[3] = src[3];
src += 4;
dest += 4;
}
return TRUE;
}
static Term
p_mod(Term t1, Term t2 USES_REGS) {
switch (ETypeOfTerm(t1)) {
case (CELL)long_int_e:
switch (ETypeOfTerm(t2)) {
case (CELL)long_int_e:
/* two integers */
{
Int i1 = IntegerOfTerm(t1);
Int i2 = IntegerOfTerm(t2);
Int mod;
if (i2 == 0)
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " mod 0", i1);
if (i1 == Int_MIN && i2 == -1) {
return MkIntTerm(0);
}
mod = i1%i2;
if (mod && (mod ^ i2) < 0)
mod += i2;
RINT(mod);
}
case (CELL)double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
case (CELL)big_int_e:
#ifdef USE_GMP
return Yap_gmp_mod_int_big(IntegerOfTerm(t1), t2);
#endif
default:
RERROR();
break;
}
case (CELL)double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
case (CELL)big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
case long_int_e:
/* modulo between bignum and integer */
{
Int i2 = IntegerOfTerm(t2);
if (i2 == 0)
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... mod 0");
return Yap_gmp_mod_big_int(t1, i2);
}
case (CELL)big_int_e:
/* two bignums */
return Yap_gmp_mod_big_big(t1, t2);
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
default:
RERROR();
}
#endif
default:
RERROR();
}
}
/**
* gimp_int_adjustment_update:
* @adjustment: A #GtkAdjustment.
* @data: A pointer to a #gint variable which will store the
* @adjustment's value.
*
* Note that the #GtkAdjustment's value (which is a #gdouble) will be
* rounded with RINT().
**/
void
gimp_int_adjustment_update (GtkAdjustment *adjustment,
gpointer data)
{
gint *val = (gint *) data;
*val = RINT (gtk_adjustment_get_value (adjustment));
}
static Term
p_rem(Term t1, Term t2) {
switch (ETypeOfTerm(t1)) {
case (CELL)long_int_e:
switch (ETypeOfTerm(t2)) {
case (CELL)long_int_e:
/* two integers */
{
Int i1 = IntegerOfTerm(t1);
Int i2 = IntegerOfTerm(t2);
Int mod;
if (i2 == 0) goto zero_divisor;
if (i1 == Int_MIN && i2 == -1) {
#ifdef USE_GMP
return Yap_gmp_add_ints(Int_MAX, 1);
#else
return Yap_ArithError(EVALUATION_ERROR_INT_OVERFLOW, t1,
"rem/2 with %d and %d", i1, i2);
#endif
}
mod = i1%i2;
RINT(i1%i2);
}
case (CELL)double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
case (CELL)big_int_e:
#ifdef USE_GMP
return Yap_gmp_rem_int_big(IntegerOfTerm(t1), t2);
#endif
default:
RERROR();
}
break;
case (CELL)double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "mod/2");
case (CELL)big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
case long_int_e:
return Yap_gmp_rem_big_int(t1, IntegerOfTerm(t2));
case (CELL)big_int_e:
/* two bignums */
return Yap_gmp_rem_big_big(t1, t2);
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
default:
RERROR();
}
#endif
default:
RERROR();
}
zero_divisor:
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is mod 0");
}
static guchar*
rgb_to_hsl (GimpDrawable *drawable,
LICEffectChannel effect_channel)
{
guchar *themap, data[4];
gint x, y;
GimpRGB color;
GimpHSL color_hsl;
gdouble val = 0.0;
glong maxc, index = 0;
GimpPixelRgn region;
GRand *gr;
gr = g_rand_new ();
maxc = drawable->width * drawable->height;
gimp_pixel_rgn_init (®ion, drawable, border_x, border_y,
border_w, border_h, FALSE, FALSE);
themap = g_new (guchar, maxc);
for (y = 0; y < region.h; y++)
{
for (x = 0; x < region.w; x++)
{
data[3] = 255;
gimp_pixel_rgn_get_pixel (®ion, data, x, y);
gimp_rgba_set_uchar (&color, data[0], data[1], data[2], data[3]);
gimp_rgb_to_hsl (&color, &color_hsl);
switch (effect_channel)
{
case LIC_HUE:
val = color_hsl.h * 255;
break;
case LIC_SATURATION:
val = color_hsl.s * 255;
break;
case LIC_BRIGHTNESS:
val = color_hsl.l * 255;
break;
}
/* add some random to avoid unstructured areas. */
val += g_rand_double_range (gr, -1.0, 1.0);
themap[index++] = (guchar) CLAMP0255 (RINT (val));
}
}
g_rand_free (gr);
return themap;
}
/* Normalise the histogram so that it integrates to unity, taking the width of
* the bins into account.
* nh - number of histogram bins
* h - histogram
* binwidth - width of each histogram bin (1/scale)
*
* required: nh, h, binwidth
* modified: h
*/
static void normhist(int nh, double h[], double binwidth, int *psh)
{
double sh = 0.0;
int i;
for(i=0; i<nh; i++)
sh += h[i];
for(i=0; i<nh; i++)
h[i]/= binwidth*sh;
*psh = RINT(sh);
}
/*
* Calculate the height and width this video should be displayed in
*/
void CDVDVideoCodecFFmpeg::GetVideoAspect(AVCodecContext* pCodecContext, unsigned int& iWidth, unsigned int& iHeight)
{
double aspect_ratio;
/* XXX: use variable in the frame */
if (pCodecContext->sample_aspect_ratio.num == 0) aspect_ratio = 0;
else aspect_ratio = av_q2d(pCodecContext->sample_aspect_ratio) * pCodecContext->width / pCodecContext->height;
if (aspect_ratio <= 0.0) aspect_ratio = (float)pCodecContext->width / (float)pCodecContext->height;
/* XXX: we suppose the screen has a 1.0 pixel ratio */ // CDVDVideo will compensate it.
iHeight = pCodecContext->height;
iWidth = ((int)RINT(pCodecContext->height * aspect_ratio)) & -3;
if (iWidth > (unsigned int)pCodecContext->width)
{
iWidth = pCodecContext->width;
iHeight = ((int)RINT(pCodecContext->width / aspect_ratio)) & -3;
}
}
static gint
draw_line (gint n,
gint startx,
gint starty,
gint pw,
gint ph,
gdouble cx1,
gdouble cy1,
gdouble cx2,
gdouble cy2,
GimpVector3 a,
GimpVector3 b)
{
gdouble x1, y1, x2, y2;
gint i = n;
gimp_vector_3d_to_2d (startx, starty, pw, ph,
&x1, &y1, &mapvals.viewpoint, &a);
gimp_vector_3d_to_2d (startx, starty, pw, ph,
&x2, &y2, &mapvals.viewpoint, &b);
if (clip_line (&x1, &y1, &x2, &y2, cx1, cy1, cx2, cy2) == TRUE)
{
linetab[i].x1 = RINT (x1);
linetab[i].y1 = RINT (y1);
linetab[i].x2 = RINT (x2);
linetab[i].y2 = RINT (y2);
linetab[i].linewidth = 3;
linetab[i].linestyle = GDK_LINE_SOLID;
gdk_gc_set_line_attributes (gc,
linetab[i].linewidth,
linetab[i].linestyle,
GDK_CAP_NOT_LAST,
GDK_JOIN_MITER);
gdk_draw_line (previewarea->window, gc,
linetab[i].x1, linetab[i].y1,
linetab[i].x2, linetab[i].y2);
i++;
}
return i;
}
/* set up lookup table */
static guchar *
gimp_brush_generated_calc_lut (gdouble radius,
gdouble hardness)
{
guchar *lookup;
gint length;
gint x;
gdouble d;
gdouble sum;
gdouble exponent;
gdouble buffer[OVERSAMPLING];
length = OVERSAMPLING * ceil (1 + sqrt (2 * SQR (ceil (radius + 1.0))));
lookup = g_malloc (length);
sum = 0.0;
if ((1.0 - hardness) < 0.0000004)
exponent = 1000000.0;
else
exponent = 0.4 / (1.0 - hardness);
for (x = 0; x < OVERSAMPLING; x++)
{
d = fabs ((x + 0.5) / OVERSAMPLING - 0.5);
if (d > radius)
buffer[x] = 0.0;
else
buffer[x] = gauss (pow (d / radius, exponent));
sum += buffer[x];
}
for (x = 0; d < radius || sum > 0.00001; d += 1.0 / OVERSAMPLING)
{
sum -= buffer[x % OVERSAMPLING];
if (d > radius)
buffer[x % OVERSAMPLING] = 0.0;
else
buffer[x % OVERSAMPLING] = gauss (pow (d / radius, exponent));
sum += buffer[x % OVERSAMPLING];
lookup[x++] = RINT (sum * (255.0 / OVERSAMPLING));
}
while (x < length)
{
lookup[x++] = 0;
}
return lookup;
}
/**
* gimp_display_shell_scroll_center_image_coordinate:
* @shell:
* @image_x:
* @image_y:
*
* Center the viewport around the passed image coordinate
*
**/
void
gimp_display_shell_scroll_center_image_coordinate (GimpDisplayShell *shell,
gdouble image_x,
gdouble image_y)
{
gint scaled_image_x;
gint scaled_image_y;
gint offset_to_apply_x;
gint offset_to_apply_y;
scaled_image_x = RINT (image_x * shell->scale_x);
scaled_image_y = RINT (image_y * shell->scale_y);
offset_to_apply_x = scaled_image_x - shell->disp_width / 2 - shell->offset_x;
offset_to_apply_y = scaled_image_y - shell->disp_height / 2 - shell->offset_y;
gimp_display_shell_scroll (shell,
offset_to_apply_x,
offset_to_apply_y);
}
static void
draw_lights (gint startx,
gint starty,
gint pw,
gint ph)
{
gdouble dxpos, dypos;
gint xpos, ypos;
clear_light_marker ();
gimp_vector_3d_to_2d (startx, starty, pw, ph,
&dxpos, &dypos, &mapvals.viewpoint,
&mapvals.lightsource.position);
xpos = RINT (dxpos);
ypos = RINT (dypos);
if (xpos >= 0 && xpos <= PREVIEW_WIDTH &&
ypos >= 0 && ypos <= PREVIEW_HEIGHT)
draw_light_marker (xpos, ypos);
}
static void
gimp_drawable_transform_rotate_point (gint x,
gint y,
GimpRotationType rotate_type,
gdouble center_x,
gdouble center_y,
gint *new_x,
gint *new_y)
{
g_return_if_fail (new_x != NULL);
g_return_if_fail (new_y != NULL);
switch (rotate_type)
{
case GIMP_ROTATE_90:
*new_x = RINT (center_x - (gdouble) y + center_y);
*new_y = RINT (center_y + (gdouble) x - center_x);
break;
case GIMP_ROTATE_180:
*new_x = RINT (center_x - ((gdouble) x - center_x));
*new_y = RINT (center_y - ((gdouble) y - center_y));
break;
case GIMP_ROTATE_270:
*new_x = RINT (center_x + (gdouble) y - center_y);
*new_y = RINT (center_y - (gdouble) x + center_x);
break;
default:
g_assert_not_reached ();
}
}
/* -----------------------------
* p_offset_update
* -----------------------------
*/
static void
p_offset_update(GtkWidget *w, gpointer data)
{
GapResizePrivateType *res_private;
gdouble ofs_x;
gdouble ofs_y;
res_private = (GapResizePrivateType *) data;
if(res_private == NULL) {return;}
ofs_x = GTK_ADJUSTMENT(res_private->offset_x_adj)->value;
ofs_y = GTK_ADJUSTMENT(res_private->offset_y_adj)->value;
res_private->offset_x = p_resize_bound_off_x (res_private, RINT(ofs_x));
res_private->offset_y = p_resize_bound_off_y (res_private, RINT(ofs_y));
gimp_offset_area_set_offsets (GIMP_OFFSET_AREA (res_private->offset_area)
, res_private->offset_x
, res_private->offset_y);
} /* end p_offset_update */
static Term
p_rem(Term t1, Term t2 USES_REGS) {
switch (ETypeOfTerm(t1)) {
case (CELL)long_int_e:
switch (ETypeOfTerm(t2)) {
case (CELL)long_int_e:
/* two integers */
{
Int i1 = IntegerOfTerm(t1);
Int i2 = IntegerOfTerm(t2);
if (i2 == 0)
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is " Int_FORMAT " rem 0", i1);
if (i1 == Int_MIN && i2 == -1) {
return MkIntTerm(0);
}
RINT(i1%i2);
}
case (CELL)double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
case (CELL)big_int_e:
#ifdef USE_GMP
return Yap_gmp_rem_int_big(IntegerOfTerm(t1), t2);
#endif
default:
RERROR();
}
break;
case (CELL)double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "mod/2");
case (CELL)big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
case long_int_e:
if (IntegerOfTerm(t2) == 0)
return Yap_ArithError(EVALUATION_ERROR_ZERO_DIVISOR, t2, "X is ... rem 0");
return Yap_gmp_rem_big_int(t1, IntegerOfTerm(t2));
case (CELL)big_int_e:
/* two bignums */
return Yap_gmp_rem_big_big(t1, t2);
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "mod/2");
default:
RERROR();
}
#endif
default:
RERROR();
}
}
static void rand_scatter_image(LTRandomGenerator *r, int w, int h, const char *name) {
int n = w * h * 128;
LTImageBuffer buf(name);
buf.width = w;
buf.height = h;
buf.bb_left = 0;
buf.bb_top = h - 1;
buf.bb_right = w - 1;
buf.bb_bottom = 0;
buf.bb_pixels = new LTpixel[w * h];
memset(buf.bb_pixels, 0xFF, w * h * 4);
for (int i = 0; i < n; i++) {
int x = RINT(r, w);
int y = RINT(r, h);
int val = (buf.bb_pixels[y * w + x] & 0xFF000000) >> 24;
if (val > 0) {
val--;
}
buf.bb_pixels[y * w + x] = (val << 8) | (val << 16) | (val << 24) | 0xFF;
}
ltWriteImage(name, &buf);
printf("Generated %s\n", name);
}
static void int_test(LTRandomGenerator *r, int n) {
int *icounts = (int*)malloc(sizeof(int) * n);
for (int i = 0; i < n; i++) {
icounts[i] = 0;
}
for (int i = 0; i < SAMPLE_SIZE; i++) {
icounts[RINT(r, n)]++;
}
printf("N = %d:\n", n);
for (int i = 0; i < n; i++) {
printf(" %d: %d\n", i, icounts[i]);
}
free(icounts);
}
void wxPlotDrawerXAxis::Draw(wxDC *dc, bool refresh)
{
wxCHECK_RET(dc, wxT("Invalid dc"));
wxRect dcRect(GetDCRect());
// Draw background
if (refresh)
{
dc->SetBrush(m_backgroundBrush.GetBrush());
dc->SetPen(*wxTRANSPARENT_PEN);
dc->DrawRectangle(dcRect);
}
wxFont tickFont = m_tickFont;
if (m_font_scale != 1)
tickFont.SetPointSize( wxMax(2, RINT(tickFont.GetPointSize() * m_font_scale)) );
dc->SetTextForeground( m_tickColour.GetColour() );
dc->SetFont( tickFont );
wxString label;
// center the text in the window
int x, y;
dc->GetTextExtent(wxT("5"), &x, &y);
int y_pos = (GetDCRect().height - y)/2 + 2; // FIXME I want to center this
// double current = ceil(m_viewRect.GetLeft() / m_xAxisTick_step) * m_xAxisTick_step;
int i, count = m_tickPositions.GetCount();
for (i=0; i<count; i++)
{
dc->DrawText(m_tickLabels[i], m_tickPositions[i], y_pos);
// if (!IsFinite(current, wxT("axis label is not finite")))
// break;
// label.Printf( m_xAxisTickFormat.c_str(), current );
// dc->DrawText(label, m_xAxisTicks[i], y_pos);
// current += m_xAxisTick_step;
}
#ifdef DRAW_BORDERS
// Test code for sizing to show the extent of the axes
dc->SetBrush( *wxTRANSPARENT_BRUSH );
dc->SetPen( *wxRED_PEN );
dc->DrawRectangle(wxRect(wxPoint(0,0), clientSize));
#endif // DRAW_BORDERS
}
static void rand_color_image(LTRandomGenerator *r, int w, int h, const char *name) {
LTImageBuffer buf(name);
buf.width = w;
buf.height = h;
buf.bb_left = 0;
buf.bb_top = h - 1;
buf.bb_right = w - 1;
buf.bb_bottom = 0;
buf.bb_pixels = new LTpixel[w * h];
for (int i = 0; i < w; i++) {
for (int j = 0; j < h; j++) {
buf.bb_pixels[j * w + i] = colors[RINT(r, ncols)];
}
}
ltWriteImage(name, &buf);
printf("Generated %s\n", name);
}
void KisSelectionFilter::computeBorder(qint32* circ, qint32 xradius, qint32 yradius)
{
qint32 i;
qint32 diameter = xradius * 2 + 1;
double tmp;
for (i = 0; i < diameter; i++) {
if (i > xradius)
tmp = (i - xradius) - 0.5;
else if (i < xradius)
tmp = (xradius - i) - 0.5;
else
tmp = 0.0;
circ[i] = (qint32) RINT(yradius / (double) xradius * sqrt(xradius * xradius - tmp * tmp));
}
}
/*
module gcd
*/
static Term
p_gcd(Term t1, Term t2 USES_REGS)
{
switch (ETypeOfTerm(t1)) {
case long_int_e:
switch (ETypeOfTerm(t2)) {
case long_int_e:
/* two integers */
{
Int i1 = IntegerOfTerm(t1), i2 = IntegerOfTerm(t2);
i1 = (i1 >= 0 ? i1 : -i1);
i2 = (i2 >= 0 ? i2 : -i2);
RINT(gcd(i1,i2 PASS_REGS));
}
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "gcd/2");
case big_int_e:
#ifdef USE_GMP
return Yap_gmp_gcd_int_big(IntegerOfTerm(t1), t2);
#endif
default:
RERROR();
}
break;
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "gcd/2");
case big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
case long_int_e:
return Yap_gmp_gcd_int_big(IntegerOfTerm(t2), t1);
case big_int_e:
return Yap_gmp_gcd_big_big(t1, t2);
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "gcd/2");
default:
RERROR();
}
#endif
default:
RERROR();
}
RERROR();
}
static gfloat
posterize_lut_func (gint *ilevels,
gint n_channels,
gint channel,
gfloat value)
{
gint levels;
/* don't posterize the alpha channel */
if ((n_channels == 2 || n_channels == 4) && channel == n_channels -1)
return value;
if (*ilevels < 2)
levels = 2;
else
levels = *ilevels;
value = RINT (value * (levels - 1.0)) / (levels - 1.0);
return value;
}
/*
xor #
*/
static Term
p_xor(Term t1, Term t2 USES_REGS)
{
switch (ETypeOfTerm(t1)) {
case long_int_e:
switch (ETypeOfTerm(t2)) {
case long_int_e:
/* two integers */
RINT(IntegerOfTerm(t1) ^ IntegerOfTerm(t2));
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "#/2");
case big_int_e:
#ifdef USE_GMP
return Yap_gmp_xor_int_big(IntegerOfTerm(t1), t2);
#endif
default:
RERROR();
}
break;
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t1, "#/2");
case big_int_e:
#ifdef USE_GMP
switch (ETypeOfTerm(t2)) {
case long_int_e:
return Yap_gmp_xor_int_big(IntegerOfTerm(t2), t1);
case big_int_e:
return Yap_gmp_xor_big_big(t1, t2);
case double_e:
return Yap_ArithError(TYPE_ERROR_INTEGER, t2, "#/2");
default:
RERROR();
}
#endif
default:
RERROR();
}
RERROR();
}
static void
d_draw_spiral (GfigObject *obj)
{
DobjPoints *center_pnt;
DobjPoints *radius_pnt;
gint16 shift_x;
gint16 shift_y;
gdouble ang_grid;
gdouble ang_loop;
gdouble radius;
gdouble offset_angle;
gdouble sp_cons;
gint loop;
GdkPoint start_pnt = { 0, 0 };
GdkPoint first_pnt;
gboolean do_line = FALSE;
gint clock_wise = 1;
center_pnt = obj->points;
if (!center_pnt)
return; /* End-of-line */
/* First point is the center */
/* Just draw a control point around it */
draw_sqr (¢er_pnt->pnt, obj == gfig_context->selected_obj);
/* Next point defines the radius */
radius_pnt = center_pnt->next; /* this defines the vetices */
if (!radius_pnt)
{
#ifdef DEBUG
g_warning ("Internal error in spiral - no vertice point \n");
#endif /* DEBUG */
return;
}
/* Other control point */
draw_sqr (&radius_pnt->pnt, obj == gfig_context->selected_obj);
/* Have center and radius - draw spiral */
shift_x = radius_pnt->pnt.x - center_pnt->pnt.x;
shift_y = radius_pnt->pnt.y - center_pnt->pnt.y;
radius = sqrt ((shift_x * shift_x) + (shift_y * shift_y));
offset_angle = atan2 (shift_y, shift_x);
clock_wise = obj->type_data / abs (obj->type_data);
if (offset_angle < 0)
offset_angle += 2.0 * G_PI;
sp_cons = radius/(obj->type_data * 2 * G_PI + offset_angle);
/* Lines */
ang_grid = 2.0 * G_PI / 180.0;
for (loop = 0 ; loop <= abs (obj->type_data * 180) +
clock_wise * (gint)RINT (offset_angle/ang_grid) ; loop++)
{
gdouble lx, ly;
GdkPoint calc_pnt;
ang_loop = (gdouble)loop * ang_grid;
lx = sp_cons * ang_loop * cos (ang_loop)*clock_wise;
ly = sp_cons * ang_loop * sin (ang_loop);
calc_pnt.x = RINT (lx + center_pnt->pnt.x);
calc_pnt.y = RINT (ly + center_pnt->pnt.y);
if (do_line)
{
/* Miss out points that come to the same location */
if (calc_pnt.x == start_pnt.x && calc_pnt.y == start_pnt.y)
continue;
gfig_draw_line (calc_pnt.x, calc_pnt.y, start_pnt.x, start_pnt.y);
}
else
{
do_line = TRUE;
first_pnt = calc_pnt;
}
start_pnt = calc_pnt;
}
}
static void
d_paint_spiral (GfigObject *obj)
{
/* first point center */
/* Next point is radius */
gdouble *line_pnts;
gint seg_count = 0;
gint i = 0;
DobjPoints *center_pnt;
DobjPoints *radius_pnt;
gint16 shift_x;
gint16 shift_y;
gdouble ang_grid;
gdouble ang_loop;
gdouble radius;
gdouble offset_angle;
gdouble sp_cons;
gint loop;
GdkPoint last_pnt = { 0, 0 };
gint clock_wise = 1;
g_assert (obj != NULL);
center_pnt = obj->points;
if (!center_pnt || !center_pnt->next)
return; /* no-line */
/* Go around all the points drawing a line from one to the next */
radius_pnt = center_pnt->next; /* this defines the vetices */
/* Have center and radius - get lines */
shift_x = radius_pnt->pnt.x - center_pnt->pnt.x;
shift_y = radius_pnt->pnt.y - center_pnt->pnt.y;
radius = sqrt ((shift_x * shift_x) + (shift_y * shift_y));
clock_wise = obj->type_data / abs (obj->type_data);
offset_angle = atan2 (shift_y, shift_x);
if (offset_angle < 0)
offset_angle += 2.0 * G_PI;
sp_cons = radius/(obj->type_data * 2.0 * G_PI + offset_angle);
/* Lines */
ang_grid = 2.0 * G_PI / 180.0;
/* count - */
seg_count = abs (obj->type_data * 180.0) + clock_wise * (gint)RINT (offset_angle/ang_grid);
line_pnts = g_new0 (gdouble, 2 * seg_count + 3);
for (loop = 0 ; loop <= seg_count; loop++)
{
gdouble lx, ly;
GdkPoint calc_pnt;
ang_loop = (gdouble)loop * ang_grid;
lx = sp_cons * ang_loop * cos (ang_loop)*clock_wise;
ly = sp_cons * ang_loop * sin (ang_loop);
calc_pnt.x = RINT (lx + center_pnt->pnt.x);
calc_pnt.y = RINT (ly + center_pnt->pnt.y);
/* Miss out duped pnts */
if (!loop)
{
if (calc_pnt.x == last_pnt.x && calc_pnt.y == last_pnt.y)
{
continue;
}
}
line_pnts[i++] = calc_pnt.x;
line_pnts[i++] = calc_pnt.y;
last_pnt = calc_pnt;
}
/* Scale before drawing */
if (selvals.scaletoimage)
scale_to_original_xy (&line_pnts[0], i / 2);
else
scale_to_xy (&line_pnts[0], i / 2);
/* One go */
if (obj->style.paint_type == PAINT_BRUSH_TYPE)
{
gfig_paint (selvals.brshtype,
gfig_context->drawable_id,
i, line_pnts);
}
g_free (line_pnts);
}