Image noise: Difference between revisions

{{omit from|Batch File}}

[[Category:Raster graphics operations]]

showing FPS (frames per second).

 

 

 

=={{header|Ada}}==

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

[[File:noise_cpp.png]]

#include <windows.h>

#include <sstream>

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

using namespace std;

}

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

 

 

 

 

 

}

}

 

}

 

}

 

 

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

 

Generating random bits with the C core.stdc.stdlib.rand the performance becomes about the same of the C version.

 

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

to 240 x 320 in code.google.com/p/x-go-binding/ui/x11/conn.go */

 

}

}

[[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|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|OCaml}}==

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

 

[[Image_Noise/OCaml/OpenGL|Equivalent]] of the C-OpenGL method.

 

=={{header|Pascal}}==

{{libheader|SDL}}

It is SDL-internally limited to 200 fps.

 

uses

lastTime := time;

end;

 

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

 

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

 

=={{header|Visual Basic .NET}}==

Windows Forms Application.

 

 

Public Class frmSnowExercise

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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