Image noise: Difference between revisions

Easy6502's built-in RNG allows for random pixels to be displayed in an infinite loop. Unfortunately these pixels are far too large to

effectively display an FPS counter, although the unused Y register in the program below could theoretically output that.

 

Snow:

 

inx ;next X

 

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

DEFINE TEXT_SIZE="40"

OD

CH=$FF

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Image_noise.png Screenshot from Atari 8-bit computer]

{{libheader|Lumen}}

noise.ads:

 

package Noise is

function Create_Image (Width, Height : Natural) return Lumen.Image.Descriptor;

 

 

noise.adb:

 

package body Noise is

end Create_Image;

 

 

test_noise.adb:

with Ada.Text_IO;

with System.Address_To_Access_Conversions;

when Program_End =>

null;

 

=={{header|Axe}}==

This example gets steady 48 FPS on a TI-84 Plus Silver Edition running at 15 MHz. It gets 26 FPS when running at 6 MHz. Some pixels appear gray because the duration of each frame is shorter than the screen's notoriously slow response time. If a pixel is toggled very quickly, it never has time to fully transition to white or black.

 

Full

.Disable memory access delays (adds 1 FPS)

Lbl FPS

N++

 

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

{{works with|BBC BASIC for Windows}}

dy% = 240

images% = 100000

SYS "SetWindowText", @hwnd%, "BBC BASIC: " + STR$(frame%*100 DIV TIME) + " fps"

ENDIF

[[File:image_noise_bbc.jpg]]

 

{{libheader|SDL}}

 

#include <stdio.h>

#include <time.h>

surf = SDL_SetVideoMode(320, 240, 8, SDL_DOUBLEBUF | SDL_HWSURFACE);

blit_noise(surf);

===Fast OpenGL method===

{{libheader|GLUT}}

Depending on your hardware, you might be able to get thousands of frames per second. Compiled with <code>gcc -lglut -lGL -g -Wall -O2</code>.

#include <GL/gl.h>

#include <stdio.h>

glutMainLoop();

return 0;

 

=={{header|C sharp|C#}}==

Max 185 FPS on .NET 4.0/Windows 7 64-bit on Athlon II X4 620 - ATI Radeon X1200.

 

using System.Collections.Generic;

using System.ComponentModel;

Application.Run();

}

 

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

[[File:noise_cpp.png]]

#include <windows.h>

#include <sstream>

}

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

 

=={{header|Common Lisp}}==

{{libheader|lispbuilder-sdl}}

noise_sdl.lisp:

 

(defun draw-noise (surface)

 

(main)

 

=={{header|D}}==

{{trans|C}}

 

void main() {

lastTime = time;

}

This D version shows about 155 FPS, while on the same PC the C version shows about 180 FPS.

 

{{libheader| System.Classes}}

{{libheader| Vcl.ExtCtrls}}

unit Main;

 

end;

 

Resources form:

object fmNoise: TfmNoise

Left = 0

end

end

{{out}}

<pre>

1400 to 1600 FPS

</pre>

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

 

Currently, Euler Math Toolbox does not have optimized routines to plot matrices with color information. The frames per second are consequently not really good.

 

>function noiseimg () ...

$aspect(320,240); clg;

>noiseimg

2.73544353263

 

=={{header|F Sharp|F#}}==

This implementation includes two methods to update the pixels values. One uses unsafe methods and can do 350 fps on my machine, the second uses safe code to marshal the new values onto the bitmap data and can do 240 fps on the same machine.

open System.Drawing

open System.Drawing.Imaging

Application.Run()

0

 

=={{header|Factor}}==

~150 FPS

 

math.parser models models.arrow random sequences threads timers

ui ui.gadgets ui.gadgets.labels ui.gadgets.packs ;

MAIN-WINDOW: open-noise-window

{ { title "Black and White noise" } }

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

' or: fbc -s gui

WindowTitle "fps = " + Str(fps)

 

 

=={{header|Go}}==

 

import (

}

}

===Optimized example===

A second example that is somewhat more optimized but maybe more complicated.

(~3000fps on a Thinkpad x220 laptop)

 

/* Note, the x-go-binding/ui/x11 lib is under development and has as a temp solution

}

}

[[File:GoNoise.png]]

 

This uses the GLFW-b bindings for GLFW 3 support:

<pre>cabal install glfw-b</pre>

import qualified Graphics.UI.GLFW as GLFW

import qualified Foreign as F

case key of

GLFW.Key'Q -> GLFW.setWindowShouldClose win True

 

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

* Using DrawImage to draw a randomly constructed bi-level images(see pg 157 of the graphics book, speed ~= 10x)

 

 

procedure main()

Event() # wait for any window event

close(&window)

 

{{libheader|Icon Programming Library}}

 

=={{header|J}}==

(coinsert[require)'jzopengl'

)

 

The script auto-starts when run (that last line <code><nowiki>p_run''</nowiki></code> is responsible for the auto-start.

 

- Very fast: 1000+ FPS on a 2.8 GHz Core Duo (with 64-bit JRE). This is capped because the maximum resolution of the timers available is 1 ms

import java.awt.event.*;

import java.awt.image.*;

});

}

 

=={{header|JavaScript}}==

[http://jsfiddle.net/bZJvr/ jsFiddle Demo]

 

<canvas id='c'></canvas>

 

animate();

</script>

About 59 frames/second on Firefox 4.

 

=={{header|Julia}}==

With Gtk, gets about 80 frames per second on a older, dual core 3 Ghz processor.

 

function randbw(ctx, w, h)

 

wait(cond)

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.awt.*

}

})

 

{{out}}

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

Generates the random bitmap programmatically, then chops it each time in a different way.

WindowWidth =411

w =320

close #w

end

 

=={{header|Maple}}==

*Note, you will need to insert a plot component to get this to work.

a:=0;

t:=time[real]();

 

end do:

 

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

time = AbsoluteTime[]; Animate[

Column[{Row[{"FPS: ", Round[n/(AbsoluteTime[] - time)]}],

RandomImage[1, {320, 240}]}], {n, 1, Infinity, 1}]

 

=={{header|MAXScript}}==

try destroydialog testRollout catch ()

createdialog testrollout

 

=={{header|Nim}}==

On a small laptop running Manjaro and without a dedicated graphic card, we get 550-600 FPS.

 

 

import opengl

start = getTime()

last = start

 

===Using library "Rapid"===

Naive implementation:

 

 

import rapid/gfx

echo 1 / (step / 60)

update step:

 

Optimized implementation using shaders:

 

 

import rapid/gfx

echo 1 / (step / 60)

update step:

 

On a Ryzen 5 1600 and a Vega 56 the naive implementation struggles to maintain 10 FPS. The GPU-powered version, however, reaches up to 12000-13000 FPS.

{{libheader|OCamlSDL}}

with the [[OCamlSDL|ocaml-sdl]] bindings:

{ contents = 0 }

 

in

Sys.catch_break true;

 

compile to native-code with:

 

In a more idiomatic way, using the modules Graphics and Unix from the standard OCaml library:

 

let white = (rgb 255 255 255)

with _ ->

flush stdout;

 

run this script with:

{{libheader|SDL}}

It is SDL-internally limited to 200 fps.

 

uses

lastTime := time;

end;

 

=={{header|Perl}}==

use Glib qw/TRUE FALSE/;

use Time::HiRes qw/ tv_interval gettimeofday/;

printf "fps: %.1f\n", $frames/$elapsed if $frames > 5;

return TRUE;

 

=={{header|Phix}}==

{{libheader|Phix/pGUI}}

Not optimised, gets about 130 fps.

include pGUI.e

 

end procedure

 

 

=={{header|PicoLisp}}==

This solution works on ErsatzLisp, the Java version of PicoLisp. It creates a 'JFrame' window, and calls inlined Java code to handle the image.

"java.util.*"

"java.awt.*" "java.awt.image.*" "javax.swing.*" )

 

# Start with 25 frames per second

 

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

declare (start_time, end_time) float (18);

declare (frame, m, n) fixed binary;

end display;

 

 

=={{header|Processing}}==

color white = color(255);

 

fill(255);

text(frameRate, 5,15);

 

==={{header|Processing Python mode}}===

white = color(255)

 

rect(0, 0, 60, 20)

fill(255)

 

=={{header|PureBasic}}==

#UpdateFreq=100 ; How often to update the FPS-display

 

Until Not Event

EndIf

[[Image:Image_Noise_in_PureBasic.png‎]]

 

{{libheader|PIL}}

 

import random

 

def __init__(self, size, root):

self.root = root

self.root.title("Image Noise Test")

 

self.label.pack()

 

self.frames = 0

self.size = size

self.loop()

 

def loop(self):

 

self.frames += 1

 

if self.frames == 30:

try:

self.time = 0

self.frames = 0

 

self.root.after(1, self.loop)

 

def main():

app = App((320, 240), root)

root.mainloop()

 

 

=={{header|Racket}}==

#lang racket

(require 2htdp/image 2htdp/universe)

[on-draw draw]

[on-tick handle-tick (/ 1. 120)])

 

=={{header|Raku}}==

Variant of a script packaged with the SDL2::Raw module.

 

use SDL2::Raw;

 

}

$fps

 

=={{header|REXX}}==

parse arg sw sd im . /*obtain optional args from the C.L. */

if sw=='' | sw=="," then sw=320 /*SW specified? No, then use default.*/

$=$ || _ /*append row to $ string.*/

end /*y*/ /* [↑] build the image. */

 

=={{header|Ruby}}==

{{libheader|ruby-opengl}}

 

require 'gl'

require 'glut'

 

Glut.glutCreateWindow "noise"

 

{{libheader|rubygems}}

{{libheader|JRubyArt}}

JRubyArt is a port of processing to ruby.

PALLETE = %w[#000000 #FFFFFF]

attr_reader :black, :dim, :white

text(frame_rate, 5, 15)

end

 

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

graphic #g, 320,240

tics = 320 * 240

print "Seconds;";totSec;" Count:";tics;" Tics / sec:";tics/totSec;" fps:";1/totSec

render #g

 

=={{header|Scala}}==

This is basically the same as the Java version, except without using BufferedImage.

import java.awt.event.{ActionEvent, ActionListener}

import swing.{Panel, MainFrame, SimpleSwingApplication}

repainter.start()

framerateChecker.start()

 

=={{header|Tcl}}==

{{libheader|Tk}}

 

proc generate {img width height} {

pack [label .l -image noise]

update

 

{{omit from|PARI/GP}}

Windows Forms Application.

 

 

Public Class frmSnowExercise

End Sub

End Class

Sample:<BR>

[[Image:SHSnowExercise.jpg]]

=={{header|Wren}}==

{{libheader|DOME}}

import "graphics" for Canvas, Color

import "random" for Random

__t = t

}

 

=={{header|XPL0}}==

intrinsic could display this image at 327 FPS if Ran(2) was faster.)

 

int CpuReg, \address of CPU register array (from GetReg)

FPS, \frames per second, the display's update rate

until KeyHit;

SetVid(3); \restore normal text mode

 

=={{header|Z80 Assembly}}==

* During the main game loop, the frame timer is also used to select a random graphics tile from among 16 possibilities, and draws it to a randomly selected tile on screen using a simple "xor-shift" routine.

 

ld hl,frametimer

ld a,(hl)

 

 

And the interrupt handler located at memory address <code>&A000</code>:

;this code runs every time the game boy finishes drawing one row of pixels, unless the interrupt is disabled as described above.

push hl

pop hl

reti ;return to main program

 

{{out}}