void FloatImage::write_pgm(char *filename, float mini, float maxi)
{
  int i,j;
  int count = xsize * ysize;

  /* maybe find minimum and maximum values */

  float min = mini;
  float max = maxi;

  if (min == 0 && max == 0) {

    get_extrema (min, max);

    if (max == min)
      min = max - 1;
  }

  unsigned char *image_data;
  image_data = new unsigned char [count];

  for (j = 0; j < ysize; j++)
    for (i = 0; i < xsize; i++) {

      int val = (int) (255 * (pixel(i,j) - min) / (max - min));

      /* clamp values */
      if (val < 0) val = 0;
      if (val > 255) val = 255;
      image_data[i+j*xsize] = val;
    }

  int fd = open(filename, O_CREAT|O_TRUNC|O_WRONLY, 0666);
  if (fd < 0) {
    fprintf(stderr, "Unable to open %s: %s\n", filename, strerror(errno));
    exit(-1);
  }

  char str[80];
  sprintf (str, "P5\n%d %d\n255\n", xsize, ysize);
  int cc = write(fd, str, strlen(str));
  if (cc == -1) {
    fprintf (stderr, "Can't write to file.\n");
    exit (-1);
  }

  cc = write(fd, image_data, sizeof(unsigned char) * xsize * ysize);

  if (cc != sizeof(unsigned char) * xsize * ysize) {
    fprintf(stderr, "Write returned short: %s\n", strerror(errno));
    close(fd);
    exit(-1);
  }

  close(fd);
}

void Bitmap::premultiplyAlpha()
{
  if(!premultiplied)
  {
    for(uint32_t x=0; x<width; ++x)
    {
      for(uint32_t y=0; y<height; ++y)
      {
        common::Color c = pixel(x,y);
        float a = c.fv[3];
        c.fv[0] = c.fv[0]*a;
        c.fv[1] = c.fv[1]*a;
        c.fv[2] = c.fv[2]*a;
        pixel(x,y,c);
      }
    }
    premultiplied = true;
  }
}

void ShowSubdiv(HWND hw)
{
	HDC	dc = GetDC	(hw);

	u32 CB = RGB(255,0,0);
	for (int z=0; z<dimZ; z++)
	{
		for (int x=0; x<dimX; x++)
		{
			Texel&	T	= texels[z*dimX+x];
			if (T.N)	{
				pixel	(dc,x,z,RGB(127,127,127));
				vertex&	N = *T.N;

				int		_x=x*3,_y=z*3;
				if		(isBorder(N,0))	{		// left
					SetPixel(dc,_x,_y+0,CB);
					SetPixel(dc,_x,_y+1,CB);
					SetPixel(dc,_x,_y+2,CB);
				}
				if		(isBorder(N,1))	{		// fwd
					SetPixel(dc,_x+0,_y,CB);
					SetPixel(dc,_x+1,_y,CB);
					SetPixel(dc,_x+2,_y,CB);
				}
				if		(isBorder(N,2))	{		// right
					SetPixel(dc,_x+2,_y+0,CB);
					SetPixel(dc,_x+2,_y+1,CB);
					SetPixel(dc,_x+2,_y+2,CB);
				}
				if		(isBorder(N,3))	{		// back
					SetPixel(dc,_x+0,_y+2,CB);
					SetPixel(dc,_x+1,_y+2,CB);
					SetPixel(dc,_x+2,_y+2,CB);
				}
			} else {
				pixel	(dc,x,z,RGB(0,127,0));
			}
		}
	}

	ReleaseDC		(hw, dc);
}

int clear(int sx, int sy, int ex, int ey)
{
	for(int j=sy; j<ey; j++)
	{
		for(int i=sx; i<ex; i++)
		{
			pixel(i, j, 0, 0, 0);
		}
	}
}

Array<Vector<T,3>,2> Image<T>::median(const vector<Array<const Vector<T,3>,2> >& images) {
  GEODE_ASSERT(images.size());
  int n = (int)images.size();
  for (int k=1;k<n;k++)
    GEODE_ASSERT(images[0].sizes()==images[k].sizes());

  Array<T,2> pixel(3,n);
  Array<Vector<T,3>,2> result(images[0].sizes());
  for(int t=0; t<result.flat.size(); t++){
    for (int k=0;k<n;k++)
      images[k].flat[t].get(pixel(0,k),pixel(1,k),pixel(2,k));
    for (int a=0;a<3;a++) {
      RawArray<T> samples = pixel[a];
      nth_element(&samples[0],&samples[n/2],&samples[n-1]);
      result.flat[t][a] = samples[n/2];
    }
  }
  return result;
}

void Utility::Yuv422FileSaver::savePacked() {
	for(std::size_t k=0; k<video_->getNumberOfFrames()&&isRunning_; k++) {
		auto frame=video_->getFrame(k);
		for(int i=0; i<width_*height_; i+=2) {
			int y1=i/width_;
			int x1=i%width_;
			int y2=(i+1)/width_;
			int x2=(i+1)%width_;

			if(!frame->valid(x1,y1)||!frame->valid(x2,y2)) {
				qDebug()<<"Wrong pixel coordinates";
				continue;
			}

			auto vec=Rgb888ToYuv422(frame->pixel(x1,y1),frame->pixel(x2,y2));
			dataStream_<<vec.getU()<<vec.getY1()<<vec.getV()<<vec.getY2();
		}
	}
}

 void copyToLedsArray(uint8_t (*state)[WIDTH][HEIGHT]) {
     for (int x = 0; x < WIDTH; x++) {
         for (int y = 0; y < HEIGHT; y++) {
             uint8_t hugh = (*state)[x][y];
             if (hugh > 0) {
                 pixel(x, y) = CHSV(hugh, 255, 255);
             }
         }
     }      
 }

/// Allow access to these pixels.
void asf::parameter_float_image::pixel_setsize(const pixel_rectangle &pixel_meta,int zoom_meta)
{
	super::pixel_setsize(pixel_meta,zoom_meta);
	int new_dx=bands(), new_dy=bands()*pixel().size_x();
	if ((data!=0) && (new_dx==xd) && (new_dy==yd))
		{ /* then re-use existing buffer--it's still OK. */ }
	else { /* Have to allocate a new buffer */
		data_alloc(src_alloc,0,new_dx,new_dy);
	}
}

void mycircle(int a,int b,int r,int c)
{
    int p=1-r,x=0,y=r;
    pixel(a,b,x,y,c);
    while(x<y)
    {
      if(p<0)
      {
      x++;
      p=p+(2*x)+1;
      }
      else
      {
      x++;
      y--;
      p=p+(2*x)-(2*y)+1;
      }
      pixel(a,b,x,y,c);
  }
}

void spinHue(void) {
  static float angle = 0.0f;
  angle += 0.001;
  if (angle > PI * 2) angle -= PI * 2;
  
  pixel(
      64.0f * (sin(angle + circleThird(0)) + 1.0f),
      64.0f * (sin(angle + circleThird(1)) + 1.0f),
      64.0f * (sin(angle + circleThird(2)) + 1.0f)
    );
}

	Rect CoordConverter::screenToWindow(const Window& window, const URect& rect)
	{
		Vector2 base(getBaseValue(window));
		Rect pixel(rect.asAbsolute(System::getSingleton().getRenderer()->getSize()));

		// negate base position
		base.d_x = -base.d_x;
		base.d_y = -base.d_y;

		return pixel.offset(base);
	}

static void drawcircle(uint8_t *data, int width) {
    int x, y;
    double hw = (double)width / 2.0 - 0.5;
    for(y = 0; y != width; y++) {
        for(x = 0; x != width; x++) {
            double dx = (x - hw), dy = (y - hw);
            double d = sqrt(dx * dx  + dy * dy) - hw + 0.5;
            *data++ = pixel(d);
        }
    }
}

void vga_fill(int w, int h, int x, int y, int c)
{
    int tx,ty;
    
    for(ty = y; ty < y+h; ty++){
        for(tx = x; tx < x+w; tx++){
            pixel(tx,ty,c);
        }
    }

}

int noise(void)
{
	for(int j=96; j<yres; j++)
	{
		for(int i=0; i<xres; i++)
		{
			char r=rand()>>23-1;
			pixel(i, j, r, r, r);
		}
	}
}

      void free_color()
	{
	  unsigned long pixels[2];
	  pixels[0] = pixel();

	  XFreeColors ( m_display,
			m_map,
			pixels,
			1,
			0 );
	}

void vga_fill_grad(int w, int h, int x, int y)
{
    int tx,ty;
    
    for(ty = y; ty < y+h; ty++){
        for(tx = x; tx < x+w; tx++){
            pixel(tx,ty,128 + ty/4);
        }
    }

}

void Picasso::circle (unsigned int x, unsigned int y, unsigned int r) {
  float rads = 0;
  
  for(float da = 1; da <= 360; da++) {
    rads = da / 180 * 3.14;
    
    pixel(
      x + (unsigned int)(cos(rads) * r),
      y + (unsigned int)(sin(rads) * r)
    );
  }
};

static void drawcross(uint8_t *data, int width) {
    int x, y;
    double hw = 0.5 * (double)(width - 1);
    double w = 0.0625 * (double)width;
    for(y = 0; y != width; y++) {
        for(x = 0; x != width; x++) {
            double dx = fabs(x - hw), dy = fabs(y - hw);
            double d = fmin(dx, dy) - w;
            *data++ = pixel(d);
        }
    }
}

lost::shared_ptr<Bitmap> Bitmap::rotCW()
{
  shared_ptr<Bitmap> result(new Bitmap(height, width, COMPONENTS_RGBA));
  for(uint32_t y=0; y<height; ++y)
  {
    for(uint32_t x=0; x<width; ++x)
    {
      result->pixel(y, x, pixel((width-1)-x,y));
    }
  }
  return result;
}

//----------------------------------------------------------------------------//
Rectf CoordConverter::screenToWindow(const Window& window, const URect& rect)
{
    Vector2f base(getBaseValue(window));
    Rectf pixel(asAbsolute(rect, window.getRootContainerSize()));

    // negate base position
    base.d_x = -base.d_x;
    base.d_y = -base.d_y;

    pixel.offset(base);
    return pixel;
}