Munching squares

From Rosetta Code
Task
Munching squares
You are encouraged to solve this task according to the task description, using any language you may know.

Render a graphical pattern where each pixel is colored by the value of 'x xor y' from an arbitrary color table.

Ada[edit]

Library: GtkAda

Uses the Cairo component of GtkAda to create and save as png

with Cairo; use Cairo;
with Cairo.Png; use Cairo.Png;
with Cairo.Image_Surface; use Cairo.Image_Surface;
procedure XorPattern is
type xorable is mod 256;
Surface : Cairo_Surface;
Data : RGB24_Array_Access;
Status : Cairo_Status;
Num : Byte;
begin
Data := new RGB24_Array(0..256*256-1);
for x in Natural range 0..255 loop
for y in Natural range 0..255 loop
Num := Byte(xorable(x) xor xorable(y));
Data(x+256*y) := RGB24_Data'(Num,0,Num);
end loop;
end loop;
Surface := Create_For_Data_RGB24(Data, 256, 256);
Status := Write_To_Png (Surface, "AdaXorPattern.png");
pragma Assert (Status = Cairo_Status_Success);
end XorPattern;
Output:
Ada Output

BBC BASIC[edit]

      size% = 256
 
VDU 23,22,size%;size%;8,8,16,0
OFF
 
DIM coltab%(size%-1)
FOR I% = 0 TO size%-1
coltab%(I%) = ((I% AND &FF) * &010101) EOR &FF0000
NEXT
 
GCOL 1
FOR I% = 0 TO size%-1
FOR J% = 0 TO size%-1
C% = coltab%(I% EOR J%)
COLOUR 1, C%, C%>>8, C%>>16
PLOT I%*2, J%*2
NEXT
NEXT I%
 
REPEAT WAIT 1 : UNTIL FALSE
 

Burlesque[edit]

 
blsq ) 0 25r@{0 25r@\/{$$Sh2' P[}\/+]m[}m[sp
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
1 0 3 2 5 4 7 6 9 8 11 10 13 12 15 14 17 16 19 18 21 20 23 22 25 24
2 3 0 1 6 7 4 5 10 11 8 9 14 15 12 13 18 19 16 17 22 23 20 21 26 27
3 2 1 0 7 6 5 4 11 10 9 8 15 14 13 12 19 18 17 16 23 22 21 20 27 26
4 5 6 7 0 1 2 3 12 13 14 15 8 9 10 11 20 21 22 23 16 17 18 19 28 29
5 4 7 6 1 0 3 2 13 12 15 14 9 8 11 10 21 20 23 22 17 16 19 18 29 28
6 7 4 5 2 3 0 1 14 15 12 13 10 11 8 9 22 23 20 21 18 19 16 17 30 31
7 6 5 4 3 2 1 0 15 14 13 12 11 10 9 8 23 22 21 20 19 18 17 16 31 30
8 9 10 11 12 13 14 15 0 1 2 3 4 5 6 7 24 25 26 27 28 29 30 31 16 17
9 8 11 10 13 12 15 14 1 0 3 2 5 4 7 6 25 24 27 26 29 28 31 30 17 16
10 11 8 9 14 15 12 13 2 3 0 1 6 7 4 5 26 27 24 25 30 31 28 29 18 19
11 10 9 8 15 14 13 12 3 2 1 0 7 6 5 4 27 26 25 24 31 30 29 28 19 18
12 13 14 15 8 9 10 11 4 5 6 7 0 1 2 3 28 29 30 31 24 25 26 27 20 21
13 12 15 14 9 8 11 10 5 4 7 6 1 0 3 2 29 28 31 30 25 24 27 26 21 20
14 15 12 13 10 11 8 9 6 7 4 5 2 3 0 1 30 31 28 29 26 27 24 25 22 23
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 31 30 29 28 27 26 25 24 23 22
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 0 1 2 3 4 5 6 7 8 9
17 16 19 18 21 20 23 22 25 24 27 26 29 28 31 30 1 0 3 2 5 4 7 6 9 8
18 19 16 17 22 23 20 21 26 27 24 25 30 31 28 29 2 3 0 1 6 7 4 5 10 11
19 18 17 16 23 22 21 20 27 26 25 24 31 30 29 28 3 2 1 0 7 6 5 4 11 10
20 21 22 23 16 17 18 19 28 29 30 31 24 25 26 27 4 5 6 7 0 1 2 3 12 13
21 20 23 22 17 16 19 18 29 28 31 30 25 24 27 26 5 4 7 6 1 0 3 2 13 12
22 23 20 21 18 19 16 17 30 31 28 29 26 27 24 25 6 7 4 5 2 3 0 1 14 15
23 22 21 20 19 18 17 16 31 30 29 28 27 26 25 24 7 6 5 4 3 2 1 0 15 14
24 25 26 27 28 29 30 31 16 17 18 19 20 21 22 23 8 9 10 11 12 13 14 15 0 1
25 24 27 26 29 28 31 30 17 16 19 18 21 20 23 22 9 8 11 10 13 12 15 14 1 0
 

Must be converted to an image with a seperate program.

C[edit]

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
 
void hue_to_rgb(double hue, double sat, unsigned char *p)
{
double x;
int c = 255 * sat;
hue /= 60;
x = (1 - fabs(fmod(hue, 2) - 1)) * 255;
 
switch((int)hue) {
case 0: p[0] = c; p[1] = x; p[2] = 0; return;
case 1: p[0] = x; p[1] = c; p[2] = 0; return;
case 2: p[0] = 0; p[1] = c; p[2] = x; return;
case 3: p[0] = 0; p[1] = x; p[2] = c; return;
case 4: p[0] = x; p[1] = 0; p[2] = c; return;
case 5: p[0] = c; p[1] = 0; p[2] = x; return;
}
}
 
int main(void)
{
const int size = 512;
int i, j;
unsigned char *colors = malloc(size * 3);
unsigned char *pix = malloc(size * size * 3), *p;
FILE *fp;
 
for (i = 0; i < size; i++)
hue_to_rgb(i * 240. / size, i * 1. / size, colors + 3 * i);
 
for (i = 0, p = pix; i < size; i++)
for (j = 0; j < size; j++, p += 3)
memcpy(p, colors + (i ^ j) * 3, 3);
 
fp = fopen("xor.ppm", "wb");
fprintf(fp, "P6\n%d %d\n255\n", size, size);
fwrite(pix, size * size * 3, 1, fp);
fclose(fp);
 
return 0;
}
Output:
C output

C++[edit]

Msquares cpp2.png

 
#include <windows.h>
#include <string>
 
//--------------------------------------------------------------------------------------------------
using namespace std;
 
//--------------------------------------------------------------------------------------------------
const int BMP_SIZE = 512;
 
//--------------------------------------------------------------------------------------------------
class myBitmap
{
public:
myBitmap() : pen( NULL ), brush( NULL ), clr( 0 ), wid( 1 ) {}
~myBitmap()
{
DeleteObject( pen );
DeleteObject( brush );
DeleteDC( hdc );
DeleteObject( bmp );
}
 
bool create( int w, int h )
{
BITMAPINFO bi;
ZeroMemory( &bi, sizeof( bi ) );
bi.bmiHeader.biSize = sizeof( bi.bmiHeader );
bi.bmiHeader.biBitCount = sizeof( DWORD ) * 8;
bi.bmiHeader.biCompression = BI_RGB;
bi.bmiHeader.biPlanes = 1;
bi.bmiHeader.biWidth = w;
bi.bmiHeader.biHeight = -h;
 
HDC dc = GetDC( GetConsoleWindow() );
bmp = CreateDIBSection( dc, &bi, DIB_RGB_COLORS, &pBits, NULL, 0 );
if( !bmp ) return false;
 
hdc = CreateCompatibleDC( dc );
SelectObject( hdc, bmp );
ReleaseDC( GetConsoleWindow(), dc );
 
width = w; height = h;
return true;
}
 
void clear( BYTE clr = 0 )
{
memset( pBits, clr, width * height * sizeof( DWORD ) );
}
 
void setBrushColor( DWORD bClr )
{
if( brush ) DeleteObject( brush );
brush = CreateSolidBrush( bClr );
SelectObject( hdc, brush );
}
 
void setPenColor( DWORD c ) { clr = c; createPen(); }
 
void setPenWidth( int w ) { wid = w; createPen(); }
 
void saveBitmap( string path )
{
BITMAPFILEHEADER fileheader;
BITMAPINFO infoheader;
BITMAP bitmap;
DWORD wb;
 
GetObject( bmp, sizeof( bitmap ), &bitmap );
DWORD* dwpBits = new DWORD[bitmap.bmWidth * bitmap.bmHeight];
 
ZeroMemory( dwpBits, bitmap.bmWidth * bitmap.bmHeight * sizeof( DWORD ) );
ZeroMemory( &infoheader, sizeof( BITMAPINFO ) );
ZeroMemory( &fileheader, sizeof( BITMAPFILEHEADER ) );
 
infoheader.bmiHeader.biBitCount = sizeof( DWORD ) * 8;
infoheader.bmiHeader.biCompression = BI_RGB;
infoheader.bmiHeader.biPlanes = 1;
infoheader.bmiHeader.biSize = sizeof( infoheader.bmiHeader );
infoheader.bmiHeader.biHeight = bitmap.bmHeight;
infoheader.bmiHeader.biWidth = bitmap.bmWidth;
infoheader.bmiHeader.biSizeImage = bitmap.bmWidth * bitmap.bmHeight * sizeof( DWORD );
 
fileheader.bfType = 0x4D42;
fileheader.bfOffBits = sizeof( infoheader.bmiHeader ) + sizeof( BITMAPFILEHEADER );
fileheader.bfSize = fileheader.bfOffBits + infoheader.bmiHeader.biSizeImage;
 
GetDIBits( hdc, bmp, 0, height, ( LPVOID )dwpBits, &infoheader, DIB_RGB_COLORS );
 
HANDLE file = CreateFile( path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
WriteFile( file, &fileheader, sizeof( BITMAPFILEHEADER ), &wb, NULL );
WriteFile( file, &infoheader.bmiHeader, sizeof( infoheader.bmiHeader ), &wb, NULL );
WriteFile( file, dwpBits, bitmap.bmWidth * bitmap.bmHeight * 4, &wb, NULL );
CloseHandle( file );
 
delete [] dwpBits;
}
 
HDC getDC() const { return hdc; }
int getWidth() const { return width; }
int getHeight() const { return height; }
 
private:
void createPen()
{
if( pen ) DeleteObject( pen );
pen = CreatePen( PS_SOLID, wid, clr );
SelectObject( hdc, pen );
}
 
HBITMAP bmp;
HDC hdc;
HPEN pen;
HBRUSH brush;
void *pBits;
int width, height, wid;
DWORD clr;
};
//--------------------------------------------------------------------------------------------------
class mSquares
{
public:
mSquares()
{
bmp.create( BMP_SIZE, BMP_SIZE );
createPallete();
}
 
void draw()
{
HDC dc = bmp.getDC();
for( int y = 0; y < BMP_SIZE; y++ )
for( int x = 0; x < BMP_SIZE; x++ )
{
int c = ( x ^ y ) % 256;
SetPixel( dc, x, y, clrs[c] );
}
 
BitBlt( GetDC( GetConsoleWindow() ), 30, 30, BMP_SIZE, BMP_SIZE, dc, 0, 0, SRCCOPY );
//bmp.saveBitmap( "f:\\rc\\msquares_cpp.bmp" );
}
 
private:
void createPallete()
{
for( int x = 0; x < 256; x++ )
clrs[x] = RGB( x<<1, x, x<<2 );//rand() % 180 + 50, rand() % 200 + 50, rand() % 180 + 50 );
}
 
unsigned int clrs[256];
myBitmap bmp;
};
//--------------------------------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
ShowWindow( GetConsoleWindow(), SW_MAXIMIZE );
srand( GetTickCount() );
mSquares s; s.draw();
return system( "pause" );
}
//--------------------------------------------------------------------------------------------------
 

C#[edit]

using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
 
class XORPattern
{
static void Main()
{
var size = 0x100;
var black = Color.Black.ToArgb();
var palette = Enumerable.Range(black, size).Select(Color.FromArgb).ToArray();
using (var image = new Bitmap(size, size))
{
for (var x = 0; x < size; x++)
{
for (var y = 0; y < size; y++)
{
image.SetPixel(x, y, palette[x ^ y]);
}
}
image.Save("XORPatternCSharp.png", ImageFormat.Png);
}
}
}
Output:

XORPatternCSharp.png

D[edit]

void main() {
import std.stdio;
 
enum width = 512, height = 512;
 
auto f = File("xor_pattern.ppm", "wb");
f.writefln("P6\n%d %d\n255", width, height);
foreach (immutable y; 0 .. height)
foreach (immutable x; 0 .. width) {
immutable c = (x ^ y) & ubyte.max;
immutable ubyte[3] u3 = [255 - c, c / 2, c];
f.rawWrite(u3);
}
}

EchoLisp[edit]

Use the plot library, hsv->rgb ((x xor y) modulo m) as color table, and see the nice results here : http://www.echolalie.org/echolisp/help.html#bit-map .

 
(lib 'types)
(lib 'plot)
(plot-size 512 512) ;; for example
 
;; use m = 16, 32, 44, .. to change the definition (number of losanges)
(define (plot-munch (m 256))
(define PIX (pixels->int32-vector)) ;; get canvas image
(define (pcolor x y) ;; color at (x,y)
(hsv->rgb
(// (bitwise-xor (modulo x m) (modulo y m)) m)
0.9
0.9))
(pixels-map pcolor PIX)
(vector->pixels PIX)) ;; draw canvas image
 
(plot-much) ;; ESC to see tge drawing
 

FreeBASIC[edit]

' version 03-11-2016
' compile with: fbc -s gui
 
Dim As ULong x, y, r, w = 256
 
ScreenRes w, w, 32
 
For x = 0 To w -1
For y = 0 To w -1
r =(x Xor y) And 255
PSet(x, y), RGB(r, r , r) ' gray scale
' PSet(x, y), RGB(r, 255 - r, 0) ' red + green
' PSet(x, y), RGB(r, 0, 0) ' red
Next
Next
 
' empty keyboard buffer
While Inkey <> "" : Wend
WindowTitle "Close window or hit any key to end program"
Sleep
End

GLSL[edit]

This is an example that will work directly on shadertoy.com, Example [1]

vec3 color;
float c,p;
vec2 b;
 
void main(void)
{
vec2 uv = gl_FragCoord.xy / iResolution.xy;
float scale = iResolution.x / iResolution.y;
uv = uv-0.5;
uv.y/=scale;
 
b = uv*256.0+256.0;
c = 0.0;
 
 
for(float i=16.0;i>=1.0;i-=1.0)
{
p = pow(2.0,i);
 
if((p < b.x) ^^
(p < b.y))
{
c += p;
}
 
if(p < b.x)
{
b.x -= p;
}
 
if(p < b.y)
{
b.y -= p;
}
 
}
 
c=mod(c/128.0,1.0);
 
color = vec3(sin(c+uv.x*cos(uv.y*1.2)), tan(c+uv.y-0.3)*1.1, cos(c-uv.y+0.9));
 
gl_FragColor = vec4(color,1.0);
}

Gnuplot[edit]

set pm3d map
set size square
set isosamples 255,255
splot [0:255][0:255]-(floor(x)^floor(y))
Output:
Gnuplot output

Haskell[edit]

import qualified Data.ByteString as BY (writeFile, pack)
 
import Data.Bits (xor)
 
main :: IO ()
main =
BY.writeFile
"out.pgm"
(BY.pack
(fmap (fromIntegral . fromEnum) "P5\n256 256\n256\n" ++
[ x `xor` y
| x <- [0 .. 255]
, y <- [0 .. 255] ]))

Go[edit]

package main
 
import (
"image"
"image/png"
"os"
)
 
func main() {
g := image.NewGray(image.Rect(0, 0, 256, 256))
for i := range g.Pix {
g.Pix[i] = uint8(i>>8 ^ i)
}
f, _ := os.Create("xor.png")
png.Encode(f, g)
f.Close()
}

Icon and Unicon[edit]

512x512 bit green and red
link printf
 
procedure main(A) #: XOR graphic
wsize := 512
cmax := 32768
wparms := ["Xmas Xor Graphic","g",sprintf("size=%d,%d",wsize),"bg=black"]
&window := open!wparms | stop("Unable to open window")
 
every y := 0 to wsize - 1 do
every x := 0 to wsize - 1 do {
c := cmax/wsize * iand(wsize-1,ixor(x,y))
Fg(sprintf("%d,%d,%d",c,cmax-c,0))
DrawPoint(x,y)
}
 
until Event() == &lpress # wait for left button to quit
close(&window)
end

printf.icn provides formatting

J[edit]

   require 'viewmat'
viewmat ~:"1/&.#: ~ i.256

Java[edit]

Library: Swing

This example will repeat the pattern if you expand the window.

import java.awt.Color;
import java.awt.Graphics;
 
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class XorPattern extends JFrame{
private JPanel xorPanel;
 
public XorPattern(){
xorPanel = new JPanel(){
@Override
public void paint(Graphics g) {
for(int y = 0; y < getHeight();y++){
for(int x = 0; x < getWidth();x++){
g.setColor(new Color(0, (x ^ y) % 256, 0));
g.drawLine(x, y, x, y);
}
}
}
};
add(xorPanel);
setSize(300, 300);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
 
public static void main(String[] args){
new XorPattern();
}
}

Xor pattern Java.png

jq[edit]

Works with: jq version 1.4

The following is an adaptation of the Ruby entry, but generates an SVG image file:

jq -n -r -f Munching_squares.jq > Munching_squares.svg

Part 1: Infrastructure

# Convert the input integer to an array of bits with lsb first
def integer_to_lsb:
[recurse(if . > 0 then ./2|floor else empty end) | . % 2] ;
 
# input array of bits (with lsb first) is converted to an integer
def lsb_to_integer:
reduce .[] as $bit
# state: [power, ans]
([1,0]; (.[0] * 2) as $b | [$b, .[1] + (.[0] * $bit)])
| .[1];
 
def xor(x;y):
def lxor(a;b): # a and/or b may be null
if a == 1 then if b==1 then 0 else 1 end
elif b==1 then if a==1 then 0 else 1 end
else 0
end;
(x|integer_to_lsb) as $s
| (y|integer_to_lsb) as $t
| ([$s|length, $t|length] | max) as $length
| reduce range(0;$length) as $i
([]; . + [ lxor($s[$i]; $t[$i]) ] )
| lsb_to_integer;

Part 2: SVG

def rgb2rgb:
def p: (. + 0.5) | floor; # to nearest integer
"rgb(\(.red|p),\(.green|p),\(.blue|p))";
 
def svg(width; height):
"<svg width='\(width // "100%")' height='\(height // "100%")'
xmlns='http://www.w3.org/2000/svg'>";
 
def pixel(x; y; color):
(color | if type == "string" then . else rgb2rgb end) as $c
| "<circle r='1' cx='\(x)' cy='\(y)' fill='\($c)' />";

Part 3: xor pattern

# rgb is a JSON object: { "red": _, "green": _, "blue": _}
 
def xor_pattern(width; height; rgb1; rgb2):
# create colour table
256 as $size
| (reduce range(0;$size) as $i
([]; . + [
{"red": (rgb1.red + (rgb2.red - rgb1.red) * $i / $size),
"green": (rgb1.green + (rgb2.green - rgb1.green) * $i / $size),
"blue": (rgb1.blue + (rgb2.blue - rgb1.blue) * $i / $size) }])
) as $colours
# create the image
| svg(width; height),
( (range(0;width) as $x
| range(0;height) as $y
| pixel($x; $y; $colours[ xor($x; $y) % $size] ) ) ),
"</svg>" ;

Part 4: Example

def black: { "red": 0, "green": 0, "blue": 0};
def red: black + { "red": 255 };
def yellow: red + { "green": 255 };
 
xor_pattern(384; 384; red; yellow)

Liberty BASIC[edit]

 
nomainwin
 
w =512
' allow for title bar and window border
WindowWidth =w +2
WindowHeight =w +34
 
open "XOR Pattern" for graphics_nsb_nf as #w
 
#w "trapclose quit"
 
#w "down"
 
for x =0 to w -1
for y =0 to w -1
b =( x xor y) and 255
print b
#w "color "; 255 -b; " "; b /2; " "; b
#w "set "; x; " "; w -y -1
scan
next y
next x
 
#w "flush"
 
wait
 
sub quit j$
close #w
end
end sub
 

Image available at [[2]]

Lua[edit]

Needs LÖVE 2D Engine

 
local clr = {}
function drawMSquares()
local pts = {}
for j = 0, hei - 1 do
for i = 0, wid - 1 do
idx = bit.bxor( i, j ) % 256
pts[1] = { i, j, clr[idx][1], clr[idx][2], clr[idx][3], 255 }
love.graphics.points( pts )
end
end
end
function createPalette()
for i = 0, 255 do
clr[i] = { bit.band( i * 2.8, 255 ), bit.band( i * 3.2, 255 ), bit.band( i * 1.5, 255 ) }
end
end
function love.load()
wid, hei = love.graphics.getWidth(), love.graphics.getHeight()
canvas = love.graphics.newCanvas( wid, hei )
love.graphics.setCanvas( canvas ); love.graphics.clear()
love.graphics.setColor( 255, 255, 255 )
createPalette(); drawMSquares();
love.graphics.setCanvas()
end
function love.draw()
love.graphics.draw( canvas )
end
 

Mathematica[edit]

ListDensityPlot[
Table[Table[
FromDigits[BitXor[IntegerDigits[x, 2, 8], IntegerDigits[y, 2, 8]],
2], {x, 0, 255}], {y, 0, 255}]]
Output #1:

Mathematica output #1

ArrayPlot[Array[BitXor, {511, 511}]]
Output #2:

Mathematica output #2

MATLAB[edit]

size = 256;
[x,y] = meshgrid([0:size-1]);
 
c = bitxor(x,y);
 
colormap bone(size);
image(c);
axis equal;
Output:
MATLAB output

OCaml[edit]

open Graphics
 
let () =
open_graph "";
resize_window 256 256;
for y = 0 to pred (size_y()) do
for x = 0 to pred (size_x()) do
let v = (x lxor y) land 0xFF in
set_color (rgb v (255 - v) 0);
plot x y
done;
done;
ignore(read_key())

Run with:

$ ocaml graphics.cma xor_pattern.ml
Output:

OCaml output

Octave[edit]

size = 256;
[x,y] = meshgrid([0:size-1]);
 
c = bitxor(x,y);
 
colormap(jet(size));
image(c);
axis equal;
Output:
Octave output

Perl[edit]

use GD;
 
my $img = new GD::Image(256, 256, 1);
 
for my $y(0..255) {
for my $x(0..255) {
my $color = $img->colorAllocate( abs(255 - $x - $y), (255-$x) ^ $y , $x ^ (255-$y));
$img->setPixel($x, $y, $color);
}
}
 
print $img->png
Output:
Perl output

Perl 6[edit]

Here's one simple way:

my $ppm = open("munching.ppm", :w) or
die "Can't create munching.ppm: $!";
 
$ppm.print(q :to 'EOT');
P3
256 256
255
EOT
 
for 0 .. 255 -> $row {
for 0 .. 255 -> $col {
my $color = $row +^ $col;
$ppm.print("0 $color 0 ");
}
$ppm.say();
}
 
$ppm.close();
 

Another way:

my @colors = map -> $r, $g, $b { Buf.new: $r, $g, $b },
map -> $x { floor ($x/256) ** 3 * 256 },
(flat (0...255) Z
(255...0) Z
flat (0,2...254),(254,252...0));
 
 
my $PPM = open "munching.ppm", :w or die "Can't create munching.ppm: $!";
 
$PPM.print: qq:to/EOH/;
P6
# munching.pgm
256 256
255
EOH
 
$PPM.write: @colors[$_] for ^256 X+^ ^256;
 
$PPM.close;

Perl 6 output

PHP[edit]

header("Content-Type: image/png");
 
$w = 256;
$h = 256;
 
$im = imagecreate($w, $h)
or die("Cannot Initialize new GD image stream");
 
$color = array();
for($i=0;$i<256;$i++)
{
array_push($color,imagecolorallocate($im,sin(($i)*(2*3.14/256))*128+128,$i/2,$i));
}
 
for($i=0;$i<$w;$i++)
{
for($j=0;$j<$h;$j++)
{
imagesetpixel($im,$i,$j,$color[$i^$j]);
}
}
 
imagepng($im);
imagedestroy($im);
Output:

PHP output

PL/I[edit]

munch: procedure options (main); /* 21 May 2014 */
 
declare screen (0:255, 0:255) bit(24) aligned;
declare b bit(8) aligned;
declare (x, y) unsigned fixed binary (8);
 
do x = 0 upthru hbound(screen,2);
do y = 0 upthru hbound(screen,1);
b = unspec(x) ^ unspec(y);
screen(x,y) = b;
end;
end;
call writeppm(screen);
end munch;

Prolog[edit]

Works with SWI-Prolog and his GUI XPCE.

xor_pattern :-
new(D, window('XOR Pattern')),
send(D, size, size(512,512)),
new(Img, image(@nil, width := 512, height := 512 , kind := pixmap)),
 
forall(between(0,511, I),
( forall(between(0,511, J),
( V is I xor J,
R is (V * 1024) mod 65536,
G is (65536 - V * 1024) mod 65536,
( V mod 2 =:= 0
-> B is (V * 4096) mod 65536
; B is (65536 - (V * 4096)) mod 65536),
send(Img, pixel(I, J, colour(@default, R, G, B))))))),
 
new(Bmp, bitmap(Img)),
send(D, display, Bmp, point(0,0)),
send(D, open).
 

Prolog xor pattern.png

PureBasic[edit]

#palletteSize = 128
Procedure.f XorPattern(x, y) ;compute the gradient value from the pixel values
Protected result = x ! y
ProcedureReturn Mod(result, #palletteSize) / #palletteSize
EndProcedure
 
Procedure drawPattern()
StartDrawing(ImageOutput(0))
DrawingMode(#PB_2DDrawing_Gradient)
CustomGradient(@XorPattern())
;specify a gradient pallette from which only specific indexes will be used
For i = 1 To #palletteSize
GradientColor(1 / i, i * $BACE9B) ; or alternatively use $BEEFDEAD
Next
Box(0, 0, ImageWidth(0), ImageHeight(0))
StopDrawing()
EndProcedure
 
If OpenWindow(0, 0, 0, 128, 128, "XOR Pattern", #PB_Window_SystemMenu)
CreateImage(0, WindowWidth(0), WindowHeight(0))
drawPattern()
ImageGadget(0, 0, 0, ImageWidth(0), ImageHeight(0), ImageID(0))
Repeat
event = WaitWindowEvent(20)
Until event = #PB_Event_CloseWindow
EndIf

Sample display of PureBasic solution

Python[edit]

Library: PIL
import Image, ImageDraw
 
image = Image.new("RGB", (256, 256))
drawingTool = ImageDraw.Draw(image)
 
for x in range(256):
for y in range(256):
drawingTool.point((x, y), (0, x^y, 0))
 
del drawingTool
image.save("xorpic.png", "PNG")

Sample produced by the above code

Racket[edit]

Munching-racket.png
 
#lang racket
(require racket/draw)
(define palette (for/vector ([x 256]) (make-object color% 0 0 x)))
(define bm (make-object bitmap% 256 256))
(define dc (new bitmap-dc% [bitmap bm]))
(for* ([x 256] [y 256])
(define c (vector-ref palette (bitwise-xor x y)))
(send dc set-pixel x y c))
bm
 

Ruby[edit]

Uses Raster graphics operations/Ruby

Sample output from Ruby program
load 'raster_graphics.rb'
 
class Pixmap
def self.xor_pattern(width, height, rgb1, rgb2)
# create colour table
size = 256
colours = Array.new(size) do |i|
RGBColour.new(
(rgb1.red + (rgb2.red - rgb1.red) * i / size),
(rgb1.green + (rgb2.green - rgb1.green) * i / size),
(rgb1.blue + (rgb2.blue - rgb1.blue) * i / size),
)
end
 
# create the image
pixmap = new(width, height)
pixmap.each_pixel do |x, y|
pixmap[x,y] = colours[(x^y)%size]
end
pixmap
end
end
 
img = Pixmap.xor_pattern(384, 384, RGBColour::RED, RGBColour::YELLOW)
img.save_as_png('xorpattern.png')

Run BASIC[edit]

w = 100
graphic #g, w,w
for x = 0 to w
for y = 0 to w
b = (x xor y) and 255
#g color(255 -b,b /2,b)
#g "set "; x; " "; w -y -1
next y
next x
render #g
#g "flush"

Rust[edit]

extern crate image;
 
use image::{ImageBuffer, Pixel, Rgb};
 
fn main() {
let mut img = ImageBuffer::new(256, 256);
 
for x in 0..256 {
for y in 0..256 {
let pixel = Rgb::from_channels(0, x as u8 ^ y as u8, 0, 0);
img.put_pixel(x, y, pixel);
}
}
 
let _ = img.save("output.png");
}

Scala[edit]

Library: Scala
import scala.swing.Swing.pair2Dimension
import scala.swing.{ Color, Graphics2D, MainFrame, Panel, SimpleSwingApplication }
 
object XorPattern extends SimpleSwingApplication {
 
val ui = new Panel {
 
override def paintComponent(g: Graphics2D) = {
super.paintComponent(g)
for {
y <- 0 until size.getHeight().toInt
x <- 0 until size.getWidth().toInt
} {
g.setColor(new Color(0, (x ^ y) % 256, 0))
g.drawLine(x, y, x, y)
}
}
}
 
def top = new MainFrame {
preferredSize = (300, 300)
title = "Rosetta Code >>> Task: Munching squares | Language: Scala"
contents = ui
centerOnScreen()
}
}

Sidef[edit]

Translation of: Perl
require('Imager')
 
var img = %O<Imager>.new(xsize => 256, ysize => 256)
 
for x,y in (^256 ~X ^256) {
var rgb = [(255 - x - y).abs, (255-x)^y, x^(255-y)]
img.setpixel(x => x, y => y, color => rgb)
}
 
img.write(file => 'xor.png')

Tcl[edit]

Library: Tk
package require Tk
 
proc xorImage {img table} {
set data {}
set h [image height $img]
set w [image width $img]
for {set y 0} {$y < $h} {incr y} {
set row {}
for {set x 0} {$x < $w} {incr x} {
lappend row [lindex $table [expr {($x^$y) % [llength $table]}]]
}
lappend data $row
}
$img put $data
}
proc inRange {i f t} {expr {$f + ($t-$f)*$i/255}}
proc mkTable {rf rt gf gt bf bt} {
for {set i 0} {$i < 256} {incr i} {
lappend tbl [format "#%02x%02x%02x" \
[inRange $i $rf $rt] [inRange $i $gf $gt] [inRange $i $bf $bt]]
}
return $tbl
}
 
set img [image create photo -width 512 -height 512]
xorImage $img [mkTable 0 255 64 192 255 0]
pack [label .l -image $img]

TI-83 BASIC[edit]

Due to the TI-83's 1 bit black and white display, this program uses the home screen and a gradient of characters. Since the TI-83 does not use a standard encoding, the first Sto→ to Str1 may be subjectively interpreted.


PROGRAM:XORPATT
" •.-,+-°-1+o*:πOX"→Str1
 
ClrHome
 
{0,0,0,0}→L1
{0,0,0,0)→L2
 
For(I,1,8,1)
For(J,1,16,1)
J→A
I→B
 
If A>8
Then
A-8→A
1→L1(1)
Else
0→L1(1)
End
 
If A>4
Then
A-4→A
1→L1(2)
Else
0→L1(2)
End
 
If A>2
Then
A-2→A
1→L1(3)
Else
0→L1(3)
End
 
If A>1
Then
1→L1(4)
Else
0→L1(4)
End
 
0→L2(1)
 
If B>4
Then
B-4→B
1→L2(2)
Else
0→L2(2)
End
 
If B>2
Then
B-2→B
1→L2(3)
Else
0→L2(3)
End
 
If B>1
Then
1→L2(4)
Else
0→L2(4)
End
 
L1≠L2→L3
8L3(1)+4L3(2)+2L3(3)+L3(4)→C
Output(I,J,sub(Str1,C+1,1))
 
End
End
Pause
 

XPL0[edit]

include c:\cxpl\codes;          \intrinsic 'code' declarations
int X, Y;
[SetVid($101); \set 640x480 graphics with 8-bit color
port($3C8):= 0; \set color registers with beautiful shades
for X:= 0 to 256-1 do
[port($3C9):= X>>1; \red
port($3C9):= X>>3; \green
port($3C9):= X; \blue
];
for Y:= 0 to 256-1 do \"color table" is array of 256 registers
for X:= 0 to 256-1 do
Point(X, Y, X|Y); \"|" = XOR, not OR which is "!"
X:= ChIn(1); \wait for keystroke
SetVid(3); \restore normal text mode
]
Output:
MunchXPL0.png

zkl[edit]

Uses the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl

Translation of: XPL0

For a kaleidoscopic image, play with coolness.

fcn muncher{
bitmap:=PPM(256,256);
coolness:=(1).random(0x10000); // 55379, 18180, 40, 51950, 57619, 43514, 65465
foreach y,x in ([0 .. 255],[0 .. 255]){
b:=x.bitXor(y); // shades of blue
// rgb:=b*coolness; // kaleidoscopic image
// rgb:=(b*coolness + b)*coolness + b; // more coolness
rgb:=(b*0x10000 + b)*0x10000 + b; // copy ADA image
bitmap[x,y]=rgb;
}
bitmap.write(File("foo.ppm","wb"));
}();

For a cheap slide show (on Linux):

while(1){ muncher(); Atomic.sleep(3); }

run ImageViewer on foo.ppm and watch it [auto] update as the image changes.

Output:

Same as the ADA image: Ada Output