Munching squares: Difference between revisions

{{omit from|Lilypond}}

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

 

=={{header|Ada}}==

{{libheader|GtkAda}}

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

with Cairo.Png; use Cairo.Png;

with Cairo.Image_Surface; use Cairo.Image_Surface;

Status := Write_To_Png (Surface, "AdaXorPattern.png");

pragma Assert (Status = Cairo_Status_Success);

{{out}} [[Image:AdaXorPattern.png|Ada Output|200px]]

 

=={{header|AWK}}==

{{works with|gawk}}

This program generates a PPM image, that you can view/convert using The GIMP or ImageMagick

BEGIN {

# square size

}

}

 

{{works with|BBC BASIC for Windows}}

 

VDU 23,22,size%;size%;8,8,16,0

 

REPEAT WAIT 1 : UNTIL FALSE

 

 

 

>2%*28*:**-2/\1-:v<:8:-1<_@ v

 

=={{header|Burlesque}}==

 

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

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.

 

=={{header|C}}==

#include <stdio.h>

#include <math.h>

 

return 0;

{{out}} [[Image:Xor_pattern_c.png|C output|200px]]

 

=={{header|C++}}==

[[File:msquares_cpp2.png|300px]]

#include <windows.h>

#include <string>

}

//--------------------------------------------------------------------------------------------------

 

 

}

 

=={{header|D}}==

import std.stdio;

 

f.rawWrite(u3);

}

 

=={{header|EchoLisp}}==

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-much) ;; ESC to see tge drawing

 

=={{header|Factor}}==

IN: rosetta-code.munching-squares

 

: main ( -- ) <munching-img> "munching.png" save-graphic-image ;

 

Output image is identical to the Racket version.

{{out}}

[[File:munching-racket.png]]

 

 

 

 

 

 

=={{header|GLSL}}==

This is an example that will work directly on shadertoy.com, Example [https://www.shadertoy.com/view/Mss3Rs]

float c,p;

vec2 b;

gl_FragColor = vec4(color,1.0);

 

=={{header|Gnuplot}}==

 

set size square

set isosamples 255,255

{{out}} [[Image:gnuplot_xor.png|Gnuplot output|200px]]

 

=={{header|Go}}==

 

import (

png.Encode(f, g)

f.Close()

 

=={{header|Icon}} and {{header|Unicon}}==

[[File:XORimage-unicon-GR512.png|thumb|right|512x512 bit green and red]]

 

procedure main(A) #: XOR graphic

until Event() == &lpress # wait for left button to quit

close(&window)

 

{{libheader|Icon Programming Library}}

 

=={{header|J}}==

 

=={{header|Java}}==

{{libheader|Swing}}

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

import java.awt.Graphics;

 

new XorPattern();

}

[[Image:Xor pattern Java.png|200px]]

 

{{works with|jq|1.4}}

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

'''Part 1: Infrastructure'''

def integer_to_lsb:

[recurse(if . > 0 then ./2|floor else empty end) | . % 2] ;

| reduce range(0;$length) as $i

([]; . + [ lxor($s[$i]; $t[$i]) ] )

'''Part 2: SVG'''

def p: (. + 0.5) | floor; # to nearest integer

"rgb(\(.red|p),\(.green|p),\(.blue|p))";

def pixel(x; y; color):

(color | if type == "string" then . else rgb2rgb end) as $c

'''Part 3: xor pattern'''

 

def xor_pattern(width; height; rgb1; rgb2):

| range(0;height) as $y

| pixel($x; $y; $colours[ xor($x; $y) % $size] ) ) ),

'''Part 4: Example'''

def red: black + { "red": 255 };

def yellow: red + { "green": 255 };

 

 

 

const can = @GtkCanvas()

@guarded draw(can) do widget

ctx = getgc(can)

end

show(can)

const cond = Condition()

signal_connect(endit, win, :destroy)

wait(cond)

 

=={{header|Kotlin}}==

 

import javax.swing.JFrame

}

}

 

=={{header|Lua}}==

function drawMSquares()

end

function createPalette()

end

function love.load()

end

function love.draw()

Table[Table[

FromDigits[BitXor[IntegerDigits[x, 2, 8], IntegerDigits[y, 2, 8]],

{{out|Output #1}}

[[File:xorpattern3.png|Mathematica output #1|200px]]

 

{{out|Output #2}}

[[File:xorpattern4.png|Mathematica output #2|200px]]

 

=={{header|MATLAB}}==

[x,y] = meshgrid([0:size-1]);

 

colormap bone(size);

image(c);

{{out}} [[File:matlab_xor.png|MATLAB output|200px]]

 

 

 

{{out}}

 

=={{header|OCaml}}==

 

 

let () =

done;

done;

 

Run with:

 

=={{header|Octave}}==

[x,y] = meshgrid([0:size-1]);

 

colormap(jet(size));

image(c);

{{out}} [[File:Xor_pattern_octave.png|Octave output|320px]]

 

=={{header|Perl}}==

 

 

my $color = $img->colorAllocate( abs(255 - $x - $y), (255-$x) ^ $y , $x ^ (255-$y));

$img->setPixel($x, $y, $color);

}

 

{{out}} [[File:perl_xor_pattern.png|Perl output|200px]]

 

=={{header|Phix}}==

 

=={{header|PHP}}==

 

$w = 256;

 

imagepng($im);

{{out}}

[[File:xor_pattern_php.png|PHP output|200px]]

 

=={{header|PL/I}}==

 

declare screen (0:255, 0:255) bit(24) aligned;

end;

call writeppm(screen);

 

=={{header|Prolog}}==

Works with SWI-Prolog and his GUI XPCE.

new(D, window('XOR Pattern')),

send(D, size, size(512,512)),

send(D, display, Bmp, point(0,0)),

send(D, open).

[[File:Prolog_xor_pattern.png|200px]]

 

=={{header|Python}}==

{{libheader|PIL}}

 

image = Image.new("RGB", (256, 256))

 

del drawingTool

[[File:PythonXORPic.png|Sample produced by the above code|200px]]

 

=={{header|Racket}}==

[[File:munching-racket.png|thumb|right]]

#lang racket

(require racket/draw)

(send dc set-pixel x y c))

bm

 

=={{header|REXX}}==

{{trans|Burlesque}}

/*───────────────────────────────────────── from an arbitrary constructed color table. */

 

Must be converted to an image with a separate program. <br><br>

 

=={{header|Ring}}==

# Project : Munching squares

 

label1 { setpicture(p1) show() }

return

Output:

 

Uses [[Raster graphics operations/Ruby]]

[[File:xorpattern_rb.png|thumb|right|Sample output from Ruby program]]

 

class Pixmap

 

img = Pixmap.xor_pattern(384, 384, RGBColour::RED, RGBColour::YELLOW)

 

=={{header|Rust}}==

 

use image::{ImageBuffer, Pixel, Rgb};

 

let _ = img.save("output.png");

 

=={{header|Scala}}==

===Scala Swing===

{{libheader|org.scala-lang.modules scala-swing}}

import scala.swing.{Color, Graphics2D, MainFrame, Panel, SimpleSwingApplication}

 

centerOnScreen()

}

 

=={{header|Sidef}}==

{{trans|Perl}}

 

var img = %O<Imager>.new(xsize => 256, ysize => 256)

}

 

Output image: [https://github.com/trizen/rc/blob/master/img/munching-squares-sidef.png Munching squares]

 

=={{header|Tcl}}==

 

proc xorImage {img table} {

set img [image create photo -width 512 -height 512]

xorImage $img [mkTable 0 255 64 192 255 0]

 

 

 

 

 

=={{header|XPL0}}==

int X, Y;

[SetVid($101); \set 640x480 graphics with 8-bit color

X:= ChIn(1); \wait for keystroke

SetVid(3); \restore normal text mode

{{out}} [[File:MunchXPL0.png]]

 

{{trans|XPL0}}

For a kaleidoscopic image, play with coolness.

bitmap:=PPM(256,256);

coolness:=(1).random(0x10000); // 55379, 18180, 40, 51950, 57619, 43514, 65465

}

bitmap.write(File("foo.ppm","wb"));

For a cheap slide show (on Linux):

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

{{out}}