Greyscale bars/Display: Difference between revisions

 

Halfway down the display, we start with black, and produce 32 bars, ending in white, and for the last quarter, we start with white and step through 62 shades of grey, before finally arriving at black in the bottom right hand corner, producing a total of 64 bars for the bottom quarter.

=={{header|ActionScript}}==

{

import flash.display.Sprite;

}

}

 

=={{header|Ada}}==

{{libheader|GTK}}

{{libheader|GtkAda}}

with Gtk.Enums;

with Gtk.Handlers;

Gtk.Main.Main;

end Greyscale;

 

=={{header|AutoHotkey}}==

Requires the GDI+ Standard Library by tic: http://www.autohotkey.com/forum/viewtopic.php?t=32238

w := A_ScreenWidth

pToken := gdip_Startup()

QColor(r, g, b){

return 0xFF000000 | (r << 16) | (g << 8) | (b)

h=ceil(graphheight/4)

for row=1 to 4

next n

next row

 

REM (0,0) is the bottom left of the display

GCOL 1 :REM Select colour one for drawing

RECTANGLE FILL w%*b%,py%,w%,256

NEXT b%

 

=={{header|C}}==

{{libheader|GTK}}

/* do some greyscale plotting */

void gsplot (cairo_t *cr,int x,int y,double s) {

gtk_main ();

return 0;

 

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

file greytones.h

</PRE>

#define MYWIDGET_H

#include <QWidget>

void paintEvent( QPaintEvent * ) ;

} ;

<pre>file greytones.cpp</pre>

#include "greytones.h"

 

run++ ;

}

<PRE>

file main.cpp

</PRE>

#include "greytones.h"

 

window.show( ) ;

return app.exec( ) ;

 

 

>function grayscale(y1,y2,n,direction=1) ...

$ loop 0 to n-1;

$endfunction

>grayscales:

 

 

=={{header|Haskell}}==

This program uses an inlined XPM file which is scaled to fill an entire GTK fullscreen window

 

import Graphics.UI.Gtk.Gdk.GC

import Control.Monad.Trans (liftIO)

"AADDFFHHJJLLNNPPRRTTVVXXZZbbddffhhjjllnnpprrttvvxxzz11336688..**",

"*+.9876543210zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCA"

 

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

 

[[File:Greyscale_unicon.png|thumb|right]]

procedure main()

put(TC.bands,band(height)) # bottom sentinal

return TC

 

{{libheader|Icon Programming Library}}

=={{header|J}}==

'''Solution:'''

rows=. (2^3+i.4),._1^i.4

bars=. ((64%{.)#[:(<:@|%~i.)*/)"1 rows

togreyscale=. (256#. [:<.255 255 255&*)"0

 

 

=={{header|Java}}==

using basically the same code as in the C++ example

import java.awt.* ;

 

public void paint ( Graphics g ) {

int run = 0 ;

for ( int columncount = 8 ; columncount < 128 ; columncount *= 2 ) {

int columnwidth = width / columncount ;

int columnheight = height / 4 ;

if ( run % 2 == 0 ) //switches color directions with every for loop

else {

}

int ystart = 0 + columnheight * run ;

int xstart = 0 ;

for ( int i = 0 ; i < columncount ; i++ ) {

g.setColor( nextColor ) ;

g.fillRect( xstart , ystart , columnwidth , columnheight ) ;

Greybars gb = new Greybars( ) ;

}

=={{header|JavaScript}}==

Live Demo: http://jsfiddle.net/gcN9g/embedded/result/

<script type="text/javascript">

var width = 640; var height = 400;

</script>

</body></html>

 

=={{header|Liberty BASIC}}==

Black boxes were added around each color for ease of counting the boxes.

nomainwin

 

end

 

Resulting [http://www.diga.me.uk/greyscale.gif GreyScale image] without the outlines.

 

 

{ If[EvenQ[#3], GrayLevel[ 1. - j/#1 ], GrayLevel[ j/#1 ]],

Rectangle[{j #2, 7*#3}, {#2 (j + 1), (#3 + 1) 7}]}, {j, 0, #1}] & @@@

{{7, 8, 3}, {15, 4, 2}, {31, 2, 1}, {63, 1, 0} }

[[File:greyscales.jpg|thumb|right]]

 

=={{header|OCaml}}==

 

 

let round x = truncate (floor (x +. 0.5))

done

) bars;

 

Run with:

<pre>$ ocaml graphics.cma greyscale_bars.ml</pre>

 

 

 

 

 

 

 

 

 

=={{header|PicoLisp}}==

(make

(for N 4

(prinl (length (car Pgm)) " " (length Pgm))

(prinl 255)

 

=={{header|PureBasic}}==

 

 

 

Next

 

CloseScreen()

Press Enter or Escape to exit the programs's display.

 

=={{header|Python}}==

#four gray scaled stripes 8:16:32:64 in Python 2.7.1

 

while keys_pressed() != [' ']: # press spacebar to close window

pass

 

=={{header|R}}==

Create a 4x64 matrix representing the described pattern, set margins to 0 so the image will fill the display, and plot the matrix in grayscale using the "image" function:

[[File:GrayscalesR.png|thumb|right]]

mat <- matrix(c(rep(1:8, each = 8) / 8,

rep(16:1, each = 4) / 16,

par(mar = rep(0, 4))

image(t(mat[4:1, ]), col = gray(1:64/64), axes = FALSE)

 

Or, this can be generalized with the function below, which produces the pattern for an arbitrary number of rows (though rows become visibly indistinguishable after about row 5):

[[File:GrayscalesR-6.png|thumb|right]]

grayscalesImage <- function(nrow = 4) {

X <- matrix(NA, nrow = nrow, ncol = 2^(nrow + 2))

## Example ##

grayscalesImage(6) # produces image shown in screenshot to the right

 

=={{header|Run BASIC}}==

incr = int(256 / (i * 8))

c = 256

next i

html "</table>"

<pre>Run in a browser</pre>

 

=={{header|Scala}}==

 

class GreyscaleBars extends Component {

}

}

Open window:

[[File:greyscalebars_scala.png|thumb|right]]

title="Greyscale bars"

visible=true

preferredSize=new Dimension(640, 320)

contents=new GreyscaleBars()

 

=={{header|Seed7}}==

include "draw.s7i";

include "keybd.s7i";

end for;

ignore(getc(KEYBOARD));

 

=={{header|Tcl}}==

{{libheader|Tk}}

package require Tk 8.5

}

incr y $dy

 

=={{header|XPL0}}==

Floating point is used to get the full range of black to white.

 

int Q, N, W, B, C, Y;

[SetVid($112); \640x480x24 graphics

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

SetVid(3); \restore normal text mode

 

=={{header|ZX Spectrum Basic}}==

and we have a set of 8 bars:

 

20 REM The ZX Spectrum display is 32 columns wide, so we have 8 columns of 4 spaces

40 FOR c=0 TO 7: REM We use the native colour sequence here

60 NEXT c

70 REM at this point the cursor has wrapped, so we don't need a newline

 

{{omit from|GUISS}}

{{omit from|Lilypond}}