Example #1
0
void blur_channels_node_t::blur_channel( int ch, const Imath::Box2i& area, const boost::gil::gray32f_view_t& tmp,
										 const Imath::V2f& radius, int iters, blur_border_mode border)
{
    if( border != border_black)
    {
        int hradius = std::ceil( radius.x);
        int vradius = std::ceil( radius.y);

        int border_x0 = std::min( area.min.x - defined().min.x, hradius);
        int border_y0 = std::min( area.min.y - defined().min.y, vradius);
        int border_x1 = std::min( defined().max.x - area.max.x, hradius);
        int border_y1 = std::min( defined().max.y - area.max.y, vradius);

        Imath::Box2i box( area);
        box.min.x -= border_x0; box.min.y -= border_y0;
        box.max.x += border_x1; box.max.y += border_y1;

        if( border == border_repeat)
          boost::gil::repeat_border_pixels( boost::gil::nth_channel_view( subimage_view( box), ch), border_x0, border_y0, border_x1, border_y1);
        else
          boost::gil::reflect_border_pixels( boost::gil::nth_channel_view( subimage_view( box), ch), border_x0, border_y0, border_x1, border_y1);
    }

    image::box_blur_channel( boost::gil::nth_channel_view( const_image_view(), ch), tmp,
							 boost::gil::nth_channel_view( image_view(), ch),
							 radius.x, radius.y, iters);
}
Example #2
0
/*
 * process_attribute: skip attributes in __attribute__((...)).
 *
 *	r)	target type
 */
static void
process_attribute(int target)
{
	int brace = 0;
	int c;
	/*
	 * Skip '...' in __attribute__((...))
	 * but pick up symbols in it.
	 */
	while ((c = nexttoken("()", cpp_reserved_word)) != EOF) {
		if (c == '(')
			brace++;
		else if (c == ')')
			brace--;
		else if (c == SYMBOL) {
			if (target == REF) {
				if (defined(token))
					PUT(token, lineno, sp);
			} else if (target == SYM) {
				if (!defined(token))
					PUT(token, lineno, sp);
			}
		}
		if (brace == 0)
			break;
	}
}
Example #3
0
/*
 * condition_macro: 
 *
 *	i)	cc	token
 *	i)	target	current target
 */
static void
condition_macro(int cc, int target)
{
	cur = &pifstack[piflevel];
	if (cc == SHARP_IFDEF || cc == SHARP_IFNDEF || cc == SHARP_IF) {
		DBG_PRINT(piflevel, "#if");
		if (++piflevel >= MAXPIFSTACK)
			die("#if pifstack over flow. [%s]", curfile);
		++cur;
		cur->start = level;
		cur->end = -1;
		cur->if0only = 0;
		if (peekc(0) == '0')
			cur->if0only = 1;
		else if ((cc = nexttoken(NULL, cpp_reserved_word)) == SYMBOL && !strcmp(token, "notdef"))
			cur->if0only = 1;
		else
			pushbacktoken();
	} else if (cc == SHARP_ELIF || cc == SHARP_ELSE) {
		DBG_PRINT(piflevel - 1, "#else");
		if (cur->end == -1)
			cur->end = level;
		else if (cur->end != level && wflag)
			warning("uneven level. [+%d %s]", lineno, curfile);
		level = cur->start;
		cur->if0only = 0;
	} else if (cc == SHARP_ENDIF) {
		int minus = 0;

		--piflevel;
		if (piflevel < 0) {
			minus = 1;
			piflevel = 0;
		}
		DBG_PRINT(piflevel, "#endif");
		if (minus) {
			if (wflag)
				warning("#if block unmatched. reseted. [+%d %s]", lineno, curfile);
		} else {
			if (cur->if0only)
				level = cur->start;
			else if (cur->end != -1) {
				if (cur->end != level && wflag)
					warning("uneven level. [+%d %s]", lineno, curfile);
				level = cur->end;
			}
		}
	}
	while ((cc = nexttoken(NULL, cpp_reserved_word)) != EOF && cc != '\n') {
                if (cc == SYMBOL && strcmp(token, "defined") != 0) {
			if (target == REF) {
				if (defined(token))
		                        PUT(token, lineno, sp);
			} else if (target == SYM) {
				if (!defined(token))
		                	PUT(token, lineno, sp);
			}
		}
	}
}
Example #4
0
void SymmetricFunction::validate() const {
    POMAGMA_INFO("Validating SymmetricFunction");

    m_lines.validate();

    POMAGMA_DEBUG("validating line-value consistency");
    for (size_t i = 1; i <= item_dim(); ++i)
        for (size_t j = i; j <= item_dim(); ++j) {
            auto val_iter = m_values.find(assert_sorted_pair(i, j));

            if (not(support().contains(i) and support().contains(j))) {
                POMAGMA_ASSERT(val_iter == m_values.end(),
                               "found unsupported lhs, rhs: " << i << ',' << j);
            } else if (val_iter != m_values.end()) {
                POMAGMA_ASSERT(defined(i, j),
                               "found undefined value: " << i << ',' << j);
                Ob val = val_iter->second;
                POMAGMA_ASSERT(val, "found zero value: " << i << ',' << j);
                POMAGMA_ASSERT(support().contains(val),
                               "found unsupported value: " << i << ',' << j);
            } else {
                POMAGMA_ASSERT(not defined(i, j),
                               "found defined null value: " << i << ',' << j);
            }
        }
}
Example #5
0
void keyer3d_node_t::do_process( const render::context_t& context)
{
	image_node_t *in0 = input_as<image_node_t>( 0);
	
	float gtol = get_value<float>( param( "gtol"));
	float gsoft = get_value<float>( param( "gsoft"));
	
	keyer().set_tol_soft_factors( gtol, gsoft);
	
    if( !input(1))
    {
		Imath::Box2i area( Imath::intersect( defined(), in0->defined()));

		if( area.isEmpty())
		    return;

		boost::gil::tbb_transform_pixels(  in0->const_subimage_view( area),
											subimage_view( area), key3d_fun( keyer()));
    }
    else
    {
		image_node_t *in1 = input_as<image_node_t>( 1);
		
		Imath::Box2i area( Imath::intersect( Imath::intersect( defined(), in0->defined()), in1->defined()));

		if( area.isEmpty())
		    return;

		boost::gil::tbb_transform2_pixels(  in0->const_subimage_view( area),
											in1->const_subimage_view( area),
											subimage_view( area), key3d_fun( keyer()));
    }
}
Example #6
0
void flip_node_t::do_process( const render::context_t& context)
{
    if( defined().isEmpty())
        return;

    calc_transform_matrix();
    image::affine_warp_nearest( input_as<image_node_t>()->defined(), input_as<image_node_t>()->const_image_view(),
                                defined(), image_view(), xform_, inv_xform_);
}
Example #7
0
void blur_node_t::do_process( const render::render_context_t& context)
{
    Imath::Box2i area( intersect( input()->defined(), defined()));

    if( area.isEmpty())
	return;

    boost::gil::copy_pixels( input()->const_subimage_view( area), subimage_view( area));

    int bmode = get_value<int>( param( "border"));

    if( bmode != border_black)
    {
        int border_x0 = area.min.x - defined().min.x;
        int border_y0 = area.min.y - defined().min.y;

        int border_x1 = defined().max.x - area.max.x;
        int border_y1 = defined().max.y - area.max.y;

        if( bmode == border_repeat)
            boost::gil::repeat_border_pixels( image_view(), border_x0, border_y0, border_x1, border_y1);
        else
            boost::gil::reflect_border_pixels( image_view(), border_x0, border_y0, border_x1, border_y1);
    }

    int channels = get_value<int>( param( "channels"));
    Imath::V2f radius = get_value<Imath::V2f>( param( "radius"));
    int iters = get_value<int>( param( "iters"));

    radius.x  /= context.subsample;
    radius.y /= context.subsample;

    switch( channels)
    {
    case channels_rgba:
	image::box_blur_rgba( const_image_view(), image_view(), radius.x, radius.y, iters);
    break;

    case channels_rgb:
    {
	image::box_blur_rgba( const_image_view(), image_view(), radius.x, radius.y, iters);
        boost::gil::fill_pixels( boost::gil::nth_channel_view( image_view(), 3), boost::gil::gray32f_pixel_t( 0));
	boost::gil::copy_pixels( boost::gil::nth_channel_view( input()->const_subimage_view( area), 3),
				boost::gil::nth_channel_view( subimage_view( area), 3));
    }
    break;

    case channels_alpha:
    {
	image::box_blur_channel( boost::gil::nth_channel_view( const_image_view(), 3),
				boost::gil::nth_channel_view( image_view(), 3),
				radius.x, radius.y, iters);
    }
    break;
    }
}
Example #8
0
static void 
exfill(void (*fill) (PLINT, PLFLT *, PLFLT *),
       PLINT (*defined) (PLFLT, PLFLT),
       int n, PLFLT *x, PLFLT *y)
{
    if (defined == NULL)

        (*fill) (n, x, y);

    else {
        PLFLT xx[16];  
	PLFLT yy[16];
	PLFLT xb, yb;  
	PLINT count = 0;
	PLINT is_inside = defined (x[n-1], y[n-1]);
	PLINT i;

        for (i = 0; i < n; i++) {

	    if (defined(x[i], y[i])) {
	        if (!is_inside) {
		    if (i > 0)
		        bisect (defined, 10,
				x[i], y[i], x[i-1], y[i-1], &xb, &yb);
		    else
		        bisect (defined, 10,
				x[i], y[i], x[n-1], y[n-1], &xb, &yb);
		    xx[count] = xb;
		    yy[count++] = yb;
		}
		xx[count] = x[i];
		yy[count++] = y[i];
		is_inside = 1;
	    }
	    else {
	        if (is_inside) {
		    if (i > 0)
		        bisect (defined, 10,
				x[i-1], y[i-1], x[i], y[i], &xb, &yb);
		    else
		        bisect (defined, 10,
				x[n-1], y[n-1], x[i], y[i], &xb, &yb);
		    xx[count] = xb;
		    yy[count++] = yb;
		    is_inside = 0;
		}
	    }
	}
	
	if (count)
  	    (*fill) (count, xx, yy);
    }
}
/*
 * Initializes the timer, and resets the timer count to 0.  Sets up the ISRs 
 * linked with timer0.
 */
void timer_init(){
	//Set up the timer to run at F_CPU / 256, in normal mode (we reset TCNT0 in the ISR)
	TCCR0A = 0x0;
	TCCR0B |= _BV(CS02);
	
	//Every _timer_micro_divisor clock ticks is one microsecond.
	_timer_micro_divisor = F_CPU / 1000000; 
	
	//Set compare value to be F_CPU / 1000 -- fire interrupt every millisecond
	OCR0A = F_CPU / 256 / 1000;
	
	//Enable compare interrupt
#if defined(__AVR_ATtiny13__)   || \
	defined(__AVR_ATtiny24__)   || \
	defined(__AVR_ATtiny44__)   || \
	defined(__AVR_ATtiny84__)   || \
	defined(__AVR_ATtiny25__)   || \
	defined(__AVR_ATtiny45__)   || \
	defined(__AVR_ATtiny85__)

	TIMSK = _BV(OCIE0A);
	
#elif defined(__AVR_ATmega48__)   || \
    defined(__AVR_ATmega48P__)    || \
	defined(__AVR_ATmega168__)   || \
	defined(__AVR_ATmega328__)     || \
	defined(__AVR_ATmega328P__)    || \
	defined(__AVR_ATmega324P__)    || \
	defined(__AVR_ATmega644__)     || \
	defined(__AVR_ATmega644P__)    || \
	defined(__AVR_ATmega644PA__)   || \
	defined(__AVR_ATmega1284P__)
	defined(__AVR_ATmega32U2__)    || \
	defined(__AVR_ATmega16U4__)    || \
	defined(__AVR_ATmega32U4__)
	
	TIMSK0 = _BV(OCIE0A);
	
#endif
	

	//Reset count variables
	_timer_millis = 0;
	
	//Enable interrupts if the NO_INTERRUPT_ENABLE define is not set.  If it is, you need to call sei() elsewhere.
#ifndef NO_INTERRUPT_ENABLE
	sei();
#endif
}
Example #10
0
void Buffer::set_min(int m0, int m1, int m2, int m3) {
    user_assert(defined()) << "Buffer is undefined\n";
    contents.ptr->buf.min[0] = m0;
    contents.ptr->buf.min[1] = m1;
    contents.ptr->buf.min[2] = m2;
    contents.ptr->buf.min[3] = m3;
}
Example #11
0
void colorx_node_t::do_process( const render::context_t& context)
{
	if( !expr_.get() || !expr_->isValid())
	{
		image::make_color_bars( image_view());
		return;
	}
	
    Imath::Box2i area( Imath::intersect( input_as<image_node_t>()->defined(), defined()));

    if( area.isEmpty())
		return;
	
	if( expr_->isThreadSafe()) // multi-threaded
	{
		tbb::parallel_for( tbb::blocked_range<int>( 0, area.size().y + 1),
						   boost::bind( &colorx_node_t::do_expression, this, _1, area, boost::cref( context)), 
						   tbb::auto_partitioner());
	}
	else
	{
		tbb::blocked_range<int> range( 0, area.size().y + 1);
		do_expression( range, area, context);
	}
}
Example #12
0
void
MaskedIcon::load_big(unsigned id, unsigned big_id, bool center)
{
  if (Layout::ScaleEnabled()) {
    if (big_id > 0)
      bitmap.load(big_id);
    else
      bitmap.load_stretch(id, Layout::FastScale(1));
  } else
    bitmap.load(id);

  assert(defined());

  size = bitmap.get_size();
  /* left half is mask, right half is icon */
  size.cx /= 2;

  if (center) {
    origin.x = size.cx / 2;
    origin.y = size.cy / 2;
  } else {
    origin.x = 0;
    origin.y = 0;
  }
}
Example #13
0
 virtual void print()
 {
   if (defined())
     cout << name << ":" << values[ value() -1] << '\n';
   else
     cout << name << ":Undefined\n";
 };
Example #14
0
bool LoopLevel::match(const LoopLevel &other) const {
    internal_assert(defined());
    return (contents->func_name == other.contents->func_name &&
            (contents->var_name == other.contents->var_name ||
             Internal::ends_with(contents->var_name, "." + other.contents->var_name) ||
             Internal::ends_with(other.contents->var_name, "." + contents->var_name)));
}
Example #15
0
static void
gen_conf(Entry * head, FILE * fp, int verbose_output)
{
    Entry *entry;
    char buf[8192];
    Line *def = NULL;

    for (entry = head; entry != NULL; entry = entry->next) {
	Line *line;

	if (!strcmp(entry->name, "comment"))
	    (void) 0;
	else if (verbose_output) {
	    fprintf(fp, "#  TAG: %s", entry->name);
	    if (entry->comment)
		fprintf(fp, "\t%s\n", entry->comment);
	    else
		fprintf(fp, "\n");
	}
	if (verbose_output) {
	    if (!defined(entry->ifdef)) {
		fprintf(fp, "# Note: This option is only available if Squid is rebuilt with the\n");
		fprintf(fp, "#       %s option\n#\n", available_if(entry->ifdef));
	    }
	    for (line = entry->doc; line != NULL; line = line->next) {
		fprintf(fp, "#%s\n", line->data);
	    }
	}
	if (entry->default_value && strcmp(entry->default_value, "none") != 0) {
	    snprintf(buf, sizeof(buf), "%s %s", entry->name, entry->default_value);
	    lineAdd(&def, buf);
	}
	if (entry->default_if_none) {
	    for (line = entry->default_if_none; line; line = line->next) {
		snprintf(buf, sizeof(buf), "%s %s", entry->name, line->data);
		lineAdd(&def, buf);
	    }
	}
	if (!def && entry->doc && strcmp(entry->name, "comment") != 0)
	    lineAdd(&def, "none");
	if (verbose_output && def && (entry->doc || entry->nocomment)) {
	    fprintf(fp, "#\n#Default:\n");
	    while (def != NULL) {
		line = def;
		def = line->next;
		fprintf(fp, "# %s\n", line->data);
		xfree(line->data);
		xfree(line);
	    }
	}
	if (verbose_output && entry->nocomment)
	    fprintf(fp, "#\n");
	for (line = entry->nocomment; line != NULL; line = line->next) {
	    fprintf(fp, "%s\n", line->data);
	}
	if (verbose_output && entry->doc != NULL) {
	    fprintf(fp, "\n");
	}
    }
}
Example #16
0
void exposure_node_t::do_process( const image::const_image_view_t& src, const image::image_view_t& dst, const render::render_context_t& context)
{
    image::const_image_view_t src_view;
    image::image_view_t dst_view;
    Imath::Box2i area;

    if( input(1))
    {
	boost::gil::copy_pixels( src, dst);
	area = intersect( input(1)->defined(), defined());

	if( area.isEmpty())
	    return;

	src_view = input(0)->const_subimage_view( area);
	dst_view = subimage_view( area);
    }
    else
    {
	src_view = src;
	dst_view = dst;
    }

    boost::gil::tbb_transform_pixels( src_view, dst_view, exposure_fun( get_value<float>( param( "exp"))));

    if( input(1))
        image::key_mix( src_view, dst_view, boost::gil::nth_channel_view( input(1)->const_subimage_view( area), 3), dst_view);
}
Example #17
0
void smart_blur_node_t::do_process( const render::context_t& context)
{
    Imath::Box2i area( ImathExt::intersect( input_as<image_node_t>()->defined(), defined()));

    if( area.isEmpty())
        return;

    Imath::V2f stddev = get_value<Imath::V2f>( param( "stddev"));
	stddev = adjust_blur_size( stddev, context.subsample);
	
	copy_src_image( 0, area, ( blur_border_mode) get_value<int>( param( "border")));
	
    blur_channels_mode channels = ( blur_channels_mode) get_value<int>( param( "channels"));
	
    switch( channels)
    {
		case channels_rgba:
		{
			image::buffer_t tmp( const_image_view().height(), const_image_view().width(), 4);
			image::smart_blur_rgba( const_image_view(), tmp.rgba_view(), image_view(), stddev.x, stddev.y, get_value<float>( param( "theresh")));
		}
		break;
	
		case channels_rgb:
		{
			image::buffer_t tmp( const_image_view().height(), const_image_view().width(), 4);
			image::smart_blur_rgba( const_image_view(), tmp.rgba_view(), image_view(), stddev.x, stddev.y, get_value<float>( param( "theresh")));			
			boost::gil::fill_pixels( boost::gil::nth_channel_view( image_view(), 3), boost::gil::gray32f_pixel_t( 0));
			boost::gil::copy_pixels( boost::gil::nth_channel_view( input_as<image_node_t>()->const_subimage_view( area), 3),
										boost::gil::nth_channel_view( subimage_view( area), 3));
		}
		break;
	}
}
Example #18
0
void
MaskedIcon::draw(Canvas &canvas, int x, int y) const
{
  assert(defined());

#ifdef ENABLE_OPENGL
  if (size.cx == 0)
    /* hack: do the postponed layout calcuation now */
    const_cast<MaskedIcon *>(this)->CalculateLayout((bool)size.cy);

  GLTexture &texture = *bitmap.native();

  GLEnable scope(GL_TEXTURE_2D);
  texture.bind();
  glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);

  GLLogicOp logic_op(GL_OR);
  texture.draw(x - origin.x, y - origin.y, size.cx, size.cy,
               0, 0, size.cx, size.cy);

  logic_op.set(GL_AND);
  texture.draw(x - origin.x, y - origin.y, size.cx, size.cy,
               size.cx, 0, size.cx, size.cy);
#else
  canvas.copy_or(x - origin.x, y - origin.y, size.cx, size.cy,
                 bitmap, 0, 0);
  canvas.copy_and(x - origin.x, y - origin.y, size.cx, size.cy,
                  bitmap, size.cx, 0);
#endif
}
Example #19
0
  /**
   * Check if this thread is the current thread.
   */
  bool inside() const {
#ifdef HAVE_POSIX
    return defined() && pthread_equal(pthread_self(), handle);
#else
    return GetCurrentThread() == handle;
#endif
  }
Example #20
0
DenseSet Router::find_defined() const {
    POMAGMA_INFO("Finding defined obs");
    DenseSet defined(m_carrier.item_dim());
    DenseSet undefined(m_carrier.item_dim());
    undefined = m_carrier.support();

    bool changed = true;
    while (changed) {
        changed = false;

        POMAGMA_DEBUG("accumulating route probabilities");

        undefined -= defined;
        for (auto iter = undefined.iter(); iter.ok(); iter.next()) {
            Ob ob = *iter;
            if (defines(defined, ob)) {
                defined.insert(ob);
                changed = true;
                break;
            }
        }
    }

    return defined;
}
Example #21
0
void lens_distort_node_t::do_process( const render::context_t& context)
{
	image_node_t *in = input_as<image_node_t>();
	
	switch( get_value<int>( param( "model")))
	{
		case syntheyes_model:
		{
			float k = get_value<float>( param( "synth_k"));
			float k3 = get_value<float>( param( "synth_k3"));
			
			if( get_value<int>( param( "mode")) == undistort)
			{
				if( k3 == 0)
				{
					camera::syntheyes_quadratic_undistort dist( k, in->format(), in->aspect_ratio());

					if( get_value<int>( param( "filter")) == bilinear)
						image::warp_bilinear( in->defined(), in->const_image_view(), defined(), image_view(), dist, false, false);
					else
						image::warp_bicubic( in->defined(), in->const_image_view(), defined(), image_view(), dist, false, false);
				}
				else
				{
					camera::syntheyes_undistort dist( k, k3, in->format(), in->aspect_ratio());
					
					if( get_value<int>( param( "filter")) == bilinear)
						image::warp_bilinear( in->defined(), in->const_image_view(), defined(), image_view(), dist, false, false);
					else
						image::warp_bicubic( in->defined(), in->const_image_view(), defined(), image_view(), dist, false, false);
				}
			}
			else
			{
				if( k3 == 0)
				{
					camera::syntheyes_quadratic_redistort dist( k, in->format(), in->aspect_ratio());

					if( get_value<int>( param( "filter")) == bilinear)
						image::warp_bilinear( in->defined(), in->const_image_view(), defined(), image_view(), dist, false, false);
					else
						image::warp_bicubic( in->defined(), in->const_image_view(), defined(), image_view(), dist, false, false);
				}
				else
				{
					camera::syntheyes_redistort dist( k, k3, in->format(), in->aspect_ratio());
					
					if( get_value<int>( param( "filter")) == bilinear)
						image::warp_bilinear( in->defined(), in->const_image_view(), defined(), image_view(), dist, false, false);
					else
						image::warp_bicubic( in->defined(), in->const_image_view(), defined(), image_view(), dist, false, false);
				}
			}
		}
		break;
	};
}
Example #22
0
int ImageBase::stride(int dim) const {
    user_assert(defined()) << "stride of undefined Image\n";
    user_assert(dim >= 0 && dim < dims)
        << "Requested stride of dimension " << dim
        << " in " << dims << "-dimensional Image \""
        << buffer.name() << "\".\n";
    return buffer.stride(dim);
}
Example #23
0
void HubSettings::merge(const HubSettings& sub) {
	for(uint8_t i = 0; i < StringCount; ++i) {
		if(defined(sub.strings[i])) {
			strings[i] = sub.strings[i];
		}
	}
	for(uint8_t i = 0; i < BoolCount; ++i) {
		if(defined(sub.bools[i])) {
			bools[i] = sub.bools[i];
		}
	}
	for(uint8_t i = 0; i < IntCount; ++i) {
		if(defined(sub.ints[i])) {
			ints[i] = sub.ints[i];
		}
	}
}
Example #24
0
void HubSettings::save(SimpleXML& xml) const {
	for(uint8_t i = 0; i < StringCount; ++i) {
		if(defined(strings[i])) {
			xml.addChildAttrib(stringNames[i], strings[i]);
		}
	}
	for(uint8_t i = 0; i < BoolCount; ++i) {
		if(defined(bools[i])) {
			xml.addChildAttrib(boolNames[i], toIntXml(bools[i]));
		}
	}
	for(uint8_t i = 0; i < IntCount; ++i) {
		if(defined(ints[i])) {
			xml.addChildAttrib(intNames[i], ints[i]);
		}
	}
}
Example #25
0
void
Font::reset()
{
  assert(!defined() || IsScreenInitialized());

  delete textUtilObject;
  textUtilObject = NULL;
}
Example #26
0
void set_matte_node_t::do_process( const render::context_t& context)
{
    if( defined().isEmpty())
	return;

    boost::gil::tbb_transform_pixels( input_as<image_node_t>( 0)->const_subimage_view( defined()), image_view(),
					  copy_rgb_and_clear_alpha());

    Imath::Box2i area = ImathExt::intersect( defined(), input_as<image_node_t>( 1)->defined());

    if( !area.isEmpty())
	boost::gil::tbb_copy_pixels( boost::gil::nth_channel_view( input_as<image_node_t>( 1)->const_subimage_view( area), 3),
					    boost::gil::nth_channel_view( subimage_view( area), 3));

    if( get_value<bool>( param( "premultiply")))
	image::premultiply( image_view(), image_view());
}
Example #27
0
const PixelSize
Bitmap::get_size() const
{
  assert(defined());

  const PixelSize size = { width, height };
  return size;
}
Example #28
0
IArrayBox&
iMultiFab::operator[] (int K)
{
    BL_ASSERT(defined(K));

    IArrayBox& fab = this->FabArray<IArrayBox>::get(K);

    return fab;
}
Example #29
0
void
Pen::reset()
{
  assert(!defined() || IsScreenInitialized());

#ifndef NDEBUG
  width = 0;
#endif
}
Example #30
0
void expand_node_t::do_process( const render::context_t& context)
{
    Imath::Box2i area = ImathExt::intersect( input_as<image_node_t>()->defined(), defined());

    if( area.isEmpty())
        return;

    boost::gil::copy_pixels( input_as<image_node_t>()->const_subimage_view( area), subimage_view( area));
}