Greyscale bars/Display: Difference between revisions

 

=={{header|ActionScript}}==

{

import flash.display.Sprite;

}

}

 

=={{header|Ada}}==

{{libheader|GTK}}

{{libheader|GtkAda}}

with Gtk.Enums;

with Gtk.Handlers;

Gtk.Main.Main;

end Greyscale;

 

=={{header|Amazing Hopper}}==

{{trans|AWK}}

Version: hopper-FLOW!

#include <flow.h>

#include <flow-term.h>

NEXT

RET

 

=={{header|ANSI Standard BASIC}}==

{{trans|BBC BASIC}}

 

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

120 SET AREA COLOR 1 ! Select color one for drawing

220 NEXT b

230 NEXT row

 

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

 

=={{header|AWK}}==

BEGIN {

nrcolors = 8

}

}

 

=={{header|BASIC256}}==

h=ceil(graphheight/4)

for row=1 to 4

next n

next row

 

=={{header|BBC BASIC}}==

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

 

=={{header|Component Pascal}}==

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

 

MODULE RosettaGreys;

IMPORT Views, Ports, Properties, Controllers, StdLog;

 

"RosettaGreys.Deposit; StdCmds.Open"

 

=={{header|EasyLang}}==

[https://easylang.online/apps/_greyscale.html Run it]

 

for row range 4

sz = 100 / n

.

n *= 2

 

=={{header|Eiffel}}==

[https://github.com/ljr1981/rosettacode_answers/blob/main/testing/rc_greyscale_bars/eifgreyscale.png PNG Output]

 

feature -- Test routines

 

down: INTEGER = -1 --| From `white' to `black' or ...

up: INTEGER = 1 --| From `black' to `white'

 

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

 

}

}

 

=={{header|FutureBasic}}==

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

_window = 1

 

 

HandleEvents

{{output}}

<pre>

</pre>

And here's another clever and shorter solution:

CGRect r = {0,0,640,400}

long i, j, bars = 8

fn BuildWindow

 

 

=={{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:'''

NB. size=. 2{.".wd'qm' NB. J6

NB. size=. getscreenwh_jgtk_ '' NB. J7

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

'rgb' viewmat (4<.@%~{:size)# (64<.@%~{.size)#"1 togreyscale bars

 

Note that hardware changes over the years have left their mark on interface protocols, which shows up here as language changes.

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

 

{{libheader|nw}}

{{libheader|cairo}}

local app = nw:app()

local cw, ch = 320, 240

end

win:show()

 

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

{{libheader|gintro}}

 

const

let app = newApplication(Application, "Rosetta.GreyscaleBars")

discard app.connect("activate", activate)

 

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

 

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/Greyscale_bars.htm here].

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Greyscale_bars.exw

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

 

=={{header|PicoLisp}}==

(make

(for N 4

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

(prinl 255)

 

=={{header|Plain English}}==

Start up.

Clear the screen.

If the flag is set, put "right-to-left" into the gradient's direction.

If the flag is not set, put "left-to-right" into the gradient's direction.

 

=={{header|Processing}}==

//Aamrun, 3rd July 2022

 

drawPanel(255,0,64,3*height/4);

}

 

=={{header|PureBasic}}==

 

Macro Check(Function)

CloseScreen()

EndIf

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

(formerly Perl 6)

my $PGM = open "Greyscale-bars-perl6.pgm", :w orelse die "Can't create Greyscale-bars-perl6.pgm: $_";

my @marks = ((1/$div,2/$div ... 1) X* $all)».round;

@marks Z- 0,|@marks;

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

 

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

{{libheader|DOME}}

import "dome" for Window

import "math" for Math

}

 

 

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