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 sharp|C#}}==

{{libheader|System.Windows.Forms}}

using System.Drawing;

using System.Windows.Forms;

return colorBars;

}

 

=={{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( ) ;

 

{{works with|Black Box Component Builder}}

 

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

 

MODULE RosettaGreys;

IMPORT Views, Ports, Properties, Controllers, StdLog;

 

"RosettaGreys.Deposit; StdCmds.Open"

 

 

=={{header|Euler Math Toolbox}}==

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

$ loop 0 to n-1;

$endfunction

>grayscales:

=={{header|FreeBASIC}}==

' compile with: fbc -s console

' or compile with: fbc -s gui

 

Sleep

 

=={{header|Frink}}==

fakewidth =!= dummy

 

g = new graphics

drawBars[g, 0, 1, 0, 1/4, 8]

drawBars[g, 1, 0, 1/4, 1/2, 16]

}

}

 

=={{header|Gambas}}==

Dim iRow, iCol, iClr As Integer 'For Row, Column and Colour

Dim iInc As Integer = 4 'To calculate RGB colour

Next

 

 

'''[http://www.cogier.com/gambas/GreyScale.png Click here for image of the output]'''

{{libheader|Go Graphics}}

{{trans|Java}}

 

import (

greyBars(dc)

dc.SavePNG("greybars.png")

 

{{out}}

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.* ;

 

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|Julia}}==

 

function generategrays(n, screenwidth)

endit(w) = notify(cond)

signal_connect(endit, win, :destroy)

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.awt.Color

fun main(args: Array<String>) {

GreyBars()

 

=={{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.

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

{ 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]]

 

 

3ds max provides customizable maps like gradient to the user, but you can also write it:

fn drawBarRow _bmp _row _width _number _inverse=

(

b = bitmap_verticalBars()

display b

 

=={{header|OCaml}}==

 

 

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

done

) bars;

 

Run with:

 

=={{header|Perl}}==

my($all, $div) = @_;

my @marks = 0;

bars($h2,$w,4,1),

bars($h3,$w,5,0),

[https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/Greyscale-bars-perl5.png See Greyscale-bars-perl5] (offsite image)

 

 

=={{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}}==

{{libheader|livewires}}

#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|Racket}}==

[[File:Grayscale-pict.png|thumb|right]]

 

#lang racket/gui

(require slideshow/pict)

(vc-append (grays 1/8 'right) (grays 1/16 'left)

(grays 1/32 'right) (grays 1/64 'left))

 

=={{header|RapidQ}}==

Declare Sub PaintCanvas

 

 

Form.showmodal

 

=={{header|Ring}}==

# Project : Greyscale bars/Display

 

}

label1 { setpicture(p1) show() }

Output:

https://www.dropbox.com/s/01iywg04iwubf55/GreyscaleBars.jpg?dl=0

 

=={{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|Yabasic}}==

w = peek("winwidth")

h = peek("winheight")

pause .1

next n

 

=={{header|zkl}}==

{{trans|XPL0}}

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

foreach q in ([0..3]){ //quarter of screen

n:=(8).shiftLeft(q); //number of bars

}

}

{{out}}

Same as the R image (but smaller):

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

25 BORDER 0: CLS

60 NEXT c

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

 

{{omit from|GUISS}}