void isometric_engine::render_torchblock(
    image_operations_ptr o,
    int bt,
    pos_t px,
    pos_t py,
    color top,
    color side
    )
{
  o->add_pixel(px, py, top);
  o->add_pixel(px - 1, py, top);
  
  top.lighten(0x20);
  top.a -= 0xb0;
  
  o->add_pixel(px, py + 1, top);
  o->add_pixel(px - 1, py + 1, top);
  
  o->add_pixel(px - 1, py + 1, side);
  o->add_pixel(px - 1, py + 2, side);
  
  side.lighten(0x20);
  
  o->add_pixel(px, py + 1, side);
  o->add_pixel(px, py + 2, side);
  
  o->add_pixel(px - 2, py, top);
  o->add_pixel(px + 1, py, top);
  o->add_pixel(px, py - 1, top);
  o->add_pixel(px - 1, py - 1, top);
}

 static color foo(color color, signed char degree)
 {
     if (degree < 0)
         return color.blend(color::black(-degree));
     else
         return color.blend(color::white(+degree));
 }

inline std::vector<std::string> getColorInfo(const color & col, const color & otherColor,
		bool getHeader = false, bool ansi = false){
	if(getHeader){
		return std::vector<std::string>{"hexStr", "hue", "sat", "lum", "alpha", "r;g;b", "r", "g", "b", "lastDiff", "closestAnsi"};
	}else{
		//"hexStr", "hue", "sat", "lum", "r;g;b", "lastDiff" ,"closestWord", "closestAnsi"
		auto closeAnsi = getClosetAnsiColor(col);
		if(ansi){
			return std::vector<std::string>{estd::to_string(col.hexStr_), estd::to_string(col.hue_),
						estd::to_string(col.lSat_), estd::to_string(col.lum_),
						estd::to_string(col.alpha_), col.getRGBStr(),
						estd::to_string(std::round(col.red_ * 255)),
						estd::to_string(std::round(col.green_ * 255)),
						estd::to_string(std::round(col.blue_ * 255)),
						estd::to_string(otherColor.getHSLDistance(col)),
				  	bib::bashCT::addBGColor(closeAnsi.first) + estd::to_string(closeAnsi.first) + bib::bashCT::reset
						};
		}else{
			return std::vector<std::string>{estd::to_string(col.hexStr_), estd::to_string(col.hue_),
						estd::to_string(col.lSat_), estd::to_string(col.lum_),
						estd::to_string(col.alpha_), col.getRGBStr(),
						estd::to_string(std::round(col.red_ * 255)),
						estd::to_string(std::round(col.green_ *255)),
						estd::to_string(std::round(col.blue_ *255)),
						estd::to_string(otherColor.getHSLDistance(col)),
				  	estd::to_string(closeAnsi.first)
						};
		}
	}
}

 inline bool operator==(color const& rhs) const
 {
     return (red_== rhs.red()) &&
            (green_ == rhs.green()) &&
            (blue_  == rhs.blue()) &&
            (alpha_ == rhs.alpha());
 }

bool color_factory::parse_from_string(color & c, std::string const& css_color,
                                      mapnik::css_color_grammar<std::string::const_iterator> const& g)
{
    std::string::const_iterator first = css_color.begin();
    std::string::const_iterator last =  css_color.end();
    // boost 1.41 -> 1.44 compatibility, to be removed in mapnik 2.1 (dane)
#if BOOST_VERSION >= 104500
    bool result =
        boost::spirit::qi::phrase_parse(first,
                                        last,
                                        g,
                                        boost::spirit::ascii::space,
                                        c);
    return result && (first == last);
#else
    mapnik::css css_;
    bool result =
        boost::spirit::qi::phrase_parse(first,
                                        last,
                                        g,
                                        boost::spirit::ascii::space,
                                        css_);
    if (result && (first == last))
    {
        c.set_red(css_.r);
        c.set_green(css_.g);
        c.set_blue(css_.b);
        c.set_alpha(css_.a);
        return true;
    }
    return false;
#endif
}

color overlay(const color& fg, const color& bg) noexcept
{
    if (opaque(fg) || transparent(bg)) return fg;
    if (transparent(fg)) return bg;

    return interpolate(bg, fg.alpha(), color{fg.red(), fg.green(), fg.blue()});
}

	void dx11render::renderLine(const point& begin, const point& end, const color& col)
	{
		if( m_device == NULL ) return;

		UINT viewportNumber = 1;

		D3D11_VIEWPORT vp;

		m_deviceContext->RSGetViewports( &viewportNumber, &vp );

		float xx0 = 2.0f * ( begin.getX() - 0.5f ) / vp.Width - 1.0f;
		float yy0 = 1.0f - 2.0f * ( begin.getY() - 0.5f ) / vp.Height;
		float xx1 = 2.0f * ( end.getX() - 0.5f ) / vp.Width - 1.0f;
		float yy1 = 1.0f - 2.0f * ( end.getY() - 0.5f ) / vp.Height;

		COLOR_VERTEX* v = NULL;
		D3D11_MAPPED_SUBRESOURCE mapData;
		if( FAILED( m_deviceContext->Map( m_pVertexBuffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &mapData ) ) )
			return;

		v = ( COLOR_VERTEX* ) mapData.pData;

		v[0].Position.x = xx0;
		v[0].Position.y = yy0;
		v[0].Position.z = 0;
		v[0].Color = col.toD3DXCOLOR();

		v[1].Position.x = xx1;
		v[1].Position.y = yy1;
		v[1].Position.z = 0;
		v[1].Color = col.toD3DXCOLOR();

		m_deviceContext->Unmap( m_pVertexBuffer, NULL );
		m_deviceContext->IASetInputLayout( m_pInputLayout );

		UINT Stride = sizeof( COLOR_VERTEX );
		UINT Offset = 0;

		m_deviceContext->IASetVertexBuffers( 0, 1, &m_pVertexBuffer, &Stride, &Offset );
		m_deviceContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP );

		D3DX11_TECHNIQUE_DESC techDesc;

		if( FAILED( m_pTechnique->GetDesc( &techDesc ) ) )
		{
			return;
		}

		for( UINT p = 0; p < techDesc.Passes; ++p )
		{
			m_pTechnique->GetPassByIndex( p )->Apply( 0, m_deviceContext );
			m_deviceContext->Draw( 2, 0 );
		}
	}

	void CDX9Renderer::Line(point p1, point p2, const color& c1, const color& c2)
	{
		// No support for textured lines
		SetTexture(NULL);

		BeginBatch(batch_lines);
		CBatch_Draw* draw_op = reinterpret_cast<CBatch_Draw*>(batch.back());

		AddVertex(c1.getD3DCOLOR(), p1, 0.0f, 0.0f);
		AddVertex(c2.getD3DCOLOR(), p2, 1.0f, 1.0f);
		draw_op->vertex_count += 2;
	}

	void CDX9Renderer::Box(const rect& r, cr_float angle, point hotspot, const color& c)
	{
		// No support for textured lines
		SetTexture(NULL);

		quad q((r - hotspot).rotate_to_quad(angle, r.topleft()));

		BeginBatch(batch_linestrip);
		CBatch_Draw* draw_op = reinterpret_cast<CBatch_Draw*>(batch.back());

		D3DCOLOR color = c.getD3DCOLOR();

		// 4 vertices and use 5th index to repeat first vertex closing the strip as a box
		AddVertex(color, q.tl, 0.0f, 0.0f);
		AddVertex(color, q.tr, 0.0f, 0.0f);
		AddVertex(color, q.br, 0.0f, 0.0f);
		AddVertex(color, q.bl, 0.0f, 0.0f);

		unsigned short index = draw_op->vertex_count;
		AddIndex(index);
		AddIndex(index + 1);
		AddIndex(index + 2);
		AddIndex(index + 3);
		AddIndex(index);

		draw_op->vertex_count += 4;
		draw_op->index_count += 5;
	}

 rect_output_attributes(const int x, const int y, const unsigned width, const unsigned height, color const& fill_color)
     : x_(x),
       y_(y),
       width_(width),
       height_(height),
       fill_color_(fill_color.to_hex_string())
 {}

	void surface::fill(rectangle rect,color col) {
		SDL_Surface* ptr = get_low();
		SDL_Rect r = rectangle::exchange_rect<SDL_Rect>(rect);
		uint32_t c = col.map_rgba();
		if(SDL_FillRect(ptr,&r,c)==-1)
			throw exception_sdl();
	}

void color::blend(const color &other) {
  if (other.is_invisible()) return;
  r = alpha_over_c(other.r, other.a, r, a);
  g = alpha_over_c(other.g, other.a, g, a);
  b = alpha_over_c(other.b, other.a, b, a);
  a = a + (other.a * (0xff - a)) / 0xff;
  r = ((r * 0xff) / a);
  g = ((g * 0xff) / a);
  b = ((b * 0xff) / a);
}

      virtual void set_background ( color& c )
      {
         m_background = &c;

         XSetWindowBackground ( m_display, m_window, c.pixel() );

         XClearWindow ( m_display, m_window );

         XFlush ( m_display );
      }

      virtual void set_background ( color& c )
	{
	  // hold a ref to the alloc'ed color
	  m_background.set ( c );

	  XSetWindowBackground ( m_display,
				 m_window,
				 c.pixel() );

	  refresh();

	}

        void display::define_light(const int & light_number, const math::transform & modelview, const math::vector & position,
                                   const color & ambient, const color & diffuse, const color & specular,
                                   const gsgl::real_t & attenuation_constant, const gsgl::real_t & attenuation_linear, const gsgl::real_t & attenuation_quadratic)
        {
            bind();

            glMatrixMode(GL_MODELVIEW);
            glLoadMatrixf(modelview.ptr());

            int gl_light = GL_LIGHT0 + light_number;

            glEnable(gl_light);
            glLightfv(gl_light, GL_AMBIENT, ambient.ptr());
            glLightfv(gl_light, GL_DIFFUSE, diffuse.ptr());
            glLightfv(gl_light, GL_SPECULAR, specular.ptr());
            glLightfv(gl_light, GL_POSITION, position.ptr());

            glLightf(gl_light, GL_CONSTANT_ATTENUATION, attenuation_constant);
            glLightf(gl_light, GL_LINEAR_ATTENUATION, attenuation_linear);
            glLightf(gl_light, GL_QUADRATIC_ATTENUATION, attenuation_quadratic);
        } // display::define_light()

void
linux_framebuffer::setcolor(const color & c)
{
	if(m_var.bits_per_pixel == 16)
	{
		//printf("R %d %d\n", m_var.red.offset, m_var.red.length);
		//printf("G %d %d\n", m_var.green.offset, m_var.green.length);
		//printf("B %d %d\n", m_var.blue.offset, m_var.blue.length);
		//printf("A %d %d\n", m_var.transp.offset, m_var.transp.length);

		constexpr size_t sizeof_colorcomponent = sizeof(c.ir()) * 8;
		const uint16_t r = (c.ir() >> (sizeof_colorcomponent - m_var.red.length)) << m_var.red.offset;
		const uint16_t g = (c.ig() >> (sizeof_colorcomponent - m_var.green.length)) << m_var.green.offset;
		const uint16_t b = (c.ib() >> (sizeof_colorcomponent - m_var.blue.length)) << m_var.blue.offset;
		const uint16_t a = (c.ia() >> (sizeof_colorcomponent - m_var.transp.length)) << m_var.transp.offset;

		//printf("assign %08x + %08x = %08x\n", m_map, offset, pos);
		m_col16 = r|g|b|a;
	}

}

void color_factory::init_from_string(color & c, std::string const& css_color)
{
    typedef std::string::const_iterator iterator_type;
    typedef mapnik::css_color_grammar<iterator_type> css_color_grammar;

    css_color_grammar g;
    iterator_type first = css_color.begin();
    iterator_type last =  css_color.end();
    // boost 1.41 -> 1.44 compatibility, to be removed in mapnik 2.1 (dane)
#if BOOST_VERSION >= 104500
    bool result =
        boost::spirit::qi::phrase_parse(first,
                                        last,
                                        g,
                                        boost::spirit::ascii::space,
                                        c);
    if (!result)
    {
        throw config_error(std::string("Failed to parse color value: ") +
                           "Expected a CSS color, but got '" + css_color + "'");
    }
#else
    mapnik::css css_;
    bool result =
        boost::spirit::qi::phrase_parse(first,
                                        last,
                                        g,
                                        boost::spirit::ascii::space,
                                        css_);
    if (!result)
    {
        throw config_error(std::string("Failed to parse color value: ") +
                           "Expected a CSS color, but got '" + css_color + "'");
    }
    c.set_red(css_.r);
    c.set_green(css_.g);
    c.set_blue(css_.b);
    c.set_alpha(css_.a);
#endif
}

   void draw_radial_marks(canvas& cnv, circle cp, float size, color c)
   {
      using namespace radial_consts;
      auto state = cnv.new_state();
      auto center = cp.center();
      constexpr auto num_divs = 50;
      float div = range / num_divs;
      auto const& theme = get_theme();

      cnv.translate({ center.x, center.y });
      cnv.stroke_style(theme.ticks_color);
      for (int i = 0; i != num_divs+1; ++i)
      {
         float from = cp.radius;
         if (i % (num_divs / 10))
         {
            // Minor ticks
            from -= size / 4;
            cnv.line_width(theme.minor_ticks_width);
            cnv.stroke_style(c.level(theme.minor_ticks_level));
         }
         else
         {
            // Major ticks
            cnv.line_width(theme.major_ticks_width);
            cnv.stroke_style(c.level(theme.major_ticks_level));
         }

         float angle = offset + (M_PI / 2) + (i * div);
         float sin_ = std::sin(angle);
         float cos_ = std::cos(angle);
         float to = cp.radius - (size / 2);

         cnv.move_to({ from * cos_, from * sin_ });
         cnv.line_to({ to * cos_, to * sin_ });
         cnv.stroke();
      }
   }

color map_palette(const color& c, int palette)
{
    if(palette < 0 || palette >= palettes.size() || palettes[palette].mapping.empty()) {
        return c;
    }

    const std::map<uint32_t,uint32_t>& mapping = palettes[palette].mapping;
    std::map<uint32_t,uint32_t>::const_iterator i = mapping.find(c.value());
    if(i != mapping.end()) {
        return color(color::convert_pixel_byte_order(i->second));
    } else {
        return c;
    }
}

	void d3d9_prim2d_lines::render_segments(const vec2* points, unsigned int point_count, const color& color) {
		ASSERT(_is_rendering);

		if (point_count > 1) {
			static_assert(sizeof(solar::vec2) == sizeof(D3DXVECTOR2), "solar::vec2 cannot be casted to D3DXVECTOR2");
			auto d3dx_points = reinterpret_cast<const D3DXVECTOR2*>(points);

			if (_viewport.X != 0 || _viewport.Y != 0) {
				//NOTE: ID3DXLine will internally transform all the points by the viewport's top left position. This causes problems because
				//all clients expect the points to be in screen space, not in the current viewport space.
				D3DMATRIX old_projection;
				D3D9_VERIFY(_context.get_device()->GetTransform(D3DTS_PROJECTION, &old_projection));
				D3DXMATRIX new_projection;
				::D3DXMatrixTranslation(&new_projection, -uint_to_float(_viewport.X), -uint_to_float(_viewport.Y), 0.f);
				new_projection *= old_projection;
				D3D9_VERIFY(_context.get_device()->SetTransform(D3DTS_PROJECTION, &new_projection));
				D3D9_VERIFY(_d3dx_line->Draw(d3dx_points, point_count, color.to_argb32()));
				D3D9_VERIFY(_context.get_device()->SetTransform(D3DTS_PROJECTION, &old_projection));
			}
			else {
				D3D9_VERIFY(_d3dx_line->Draw(d3dx_points, point_count, color.to_argb32()));
			}
		}
	}