Bitmap: Difference between revisions

{{task|Raster graphics operations}}

 

Show a basic storage type to handle a simple RGB raster graphics image,

is available in the article [[write ppm file]].''

<br><br>

 

=={{header|ActionScript}}==

ActionScript 3 has a [http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/BitmapData.html BitmapData class] (in the <code>flash.display</code> package) which can be used for storage and handling of bitmap images.

To display these images, the [http://help.adobe.com/en_US/FlashPlatform/reference/actionscript/3/flash/display/Bitmap.html Bitmap] class can be used.

 

// To import the BitmapData class:

import flash.display.BitmapData;

// Fill the bitmap with a given colour (as 0xAARRGGBB) after construction

bitmap.fillRect(bitmap.rect, 0xFF44FF44);

=={{header|Ada}}==

The package interface:

type Luminance is mod 2**8;

type Pixel is record

X, Y : Positive;

end record;

The implementation of:

 

package body Bitmap_Store is

end Print;

 

This can be used like:

...

X : Image (1..64, 1..64);

Fill (X, (255, 255, 255));

X (1, 2) := (R => 255, others => 0);

=={{header|ALGOL 68}}==

{{trans|ada}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.6 algol68g-2.6].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

 

MODE PIXEL = STRUCT(#SHORT# BITS red,green,blue);

OP INIT = (REF IMAGE image)REF IMAGE: (init OF (CLASSOF image))(image);

 

# -*- coding: utf-8 -*- #

 

(fill OF class image) (x, white OF class image);

(print OF class image) (x)

{{out}} (A 16x16 white block)

<pre>

ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

</pre>

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

blue := color(0,0,255) ; rgb

cyan := color(0,255,255)

{

return clr.R << 16 | clr.G << 8 | clr.B

 

=={{header|Axe}}==

Two bitmaps can be masked together to create 3- and 4-color grayscale.

 

Fill(Pic1,768,255)

Pxl-Off(45,30,Pic1)

Pause 4500

 

 

[[Image:BASIC256_bitmap.png|right]]

call fill(rgb(255,0,0))

call setpixel(10,10,rgb(0,255,255))

color c

plot x,y

{{out}}

<pre>pixel 10,10 is 4278255615

pixel 20,20 is 4294901760</pre>

 

{{works with|BBC BASIC for Windows}}

BBC BASIC expects a bitmap always to be associated with a window;

for simplicity this code uses the main output window.

Height% = 200

col% = TINT(x%*2,y%*2)

SWAP ?^col%,?(^col%+2)

=={{header|C}}==

 

Start from [[Bitmap| bitmap page]]

 

#define _IMGLIB_0

 

color_component b );

#define GET_PIXEL(IMG, X, Y) (IMG->buf[ ((Y) * IMG->width + (X)) ])

 

{

image img;

if (x < img->width && y < img->height)

put_pixel_unsafe(img, x, y, r, g, b);

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

This implementation uses a multidemensional array to store the Color structure

No exception catching for out-of-bounds errors if they occur,

but provides Height and Width properties so a program using it can avoid them.

{

public struct Color

_imagemap[x, y] = color;

}

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

 

{{libheader|boost}}

 

#include <boost/gil/gil_all.hpp>

int main()

rgb8_pixel_t px = const_view(img)(11, 20);

std::cout << "the pixel at 11, 20 is " << (unsigned)px[0] << ':' << (unsigned)px[1] << ':' << (unsigned)px[2] << '\n';

 

See also [[Basic bitmap storage/C++]]

=={{header|Clojure}}==

'[java.awt.image BufferedImage])

 

 

(defn get-pixel [image x y]

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

 

(:use #:common-lisp)

(:export #:rgb-pixel-component #:rgb-pixel #:rgb-pixel-buffer

#:make-rgb-pixel #:make-rgb-pixel-buffer #:rgb-pixel-buffer-width

#:rgb-pixel-buffer-height #:rgb-pixel-red #:rgb-pixel-green

 

 

(deftype rgb-pixel-component ()

:for x :of-type fixnum :upfrom 0 :below width

:do (setf (rgb-pixel buffer x y) pixel)))

 

Example:

 

(fill-rgb-pixel-buffer *buffer* +white+)

(setf (rgb-pixel *buffer* 0 0) +red+)

(setf (rgb-pixel *buffer* 0 9) +red+)

(setf (rgb-pixel *buffer* 9 0) +red+)

=={{header|Crystal}}==

class RGBColor

getter red, green, blue

bmap = Pixmap.new(5, 5)

pp bmap

=={{header|D}}==

This code is a little complex because many Tasks use this module for various purposes.

 

import std.stdio, std.array, std.exception, std.string, std.conv,

img.textualShow;

}

Compiling it with <code>version=bitmap_main</code> prints:

{{out}}

##############################</pre>

=={{header|Delphi}}==

program BitmapTest;

 

end;

bmp.Free;

=={{header|E}}==

 

because it is most naturally written as a method on the image object.

 

def format := <import:java.lang.makeString>.format

 

return flexImage

 

Examples/tests:

 

# value: [000000 000000 000000 ]

# [000000 000000 000000 ]

# value: 808080

 

=={{header|EchoLisp}}==

(lib 'plot)

(define width 600)

(blue-at-xy 100 200)

→ 255

=={{header|Elixir}}==

Translation of the erlang version of the code.

 

defmodule RosBitmap do

defrecord Bitmap, pixels: nil, shape: {0, 0}

end

end

=={{header|Erlang}}==

 

Stores pixels as a 1d array and colors as binaries.

 

-module(ros_bitmap).

 

<<R:8, G:8, B:8>> = array:get(Index, Pixels),

{rgb, R, G, B}.

=={{header|Euphoria}}==

constant

black = #000000,

-- Get pixel color

atom color

?color -- Should print out 16711680

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

FSharp can accomplish this task in several ways. This version is purely functional. The bitmap data structure does not mutate. Set pixel, for example, simply transforms the input bitmap into a new bitmap with that pixel set to the input color. If you have Framework 4.5, you can use ImmutableArray to force this immutability.

 

'''Solution:'''

//pure functional version ... changing a pixel color provides a new Bitmap

type Color = {red: byte; green: byte; blue: byte}

| _ -> id)}

let fill color bitmap = {bitmap with color = bitmap.color |> Array.map (fun _ ->color)}

 

'''Tests:'''

//setups

//==check pixel for color function

let myBitmap6 = myBitmap5 |> setPixel {x=5u;y=10u} colorBlack

printfn "Is 5,10 black: %b" (check myBitmap4 colorBlack (5u,10u))

{{out}}Is empty: true

 

Is 5,10 black: true

'''Usage:'''

bitmap 14u 14u

|> fill {red = (byte) 200; green = (byte) 0; blue = (byte) 10}

|> getPixel {x=5u;y=10u}

|> printfn "%A"

{{out}}

Some {red = 0uy;

green = 0uy;

blue = 0uy;}

=={{header|Factor}}==

The image is a matrix of triples {R,G,B}.

most of them are not used right now, but we need them for drawing

so I put every thing here..

IN: rosettacode.raster.storage

 

: set-pixel ( {R,G,B} {i,j} image -- ) set-Mi,j ; inline

: get-pixel ( {i,j} image -- pixel ) Mi,j ; inline

=={{header|FBSL}}==

Volatility in FBSL is a feature uncommon to most other languages. It is the ability of its intrinsic functions as well as its user-defined functions, DynAsm and DynC blocks, and functions imported from 3rd-party DLL's to preserve their return values between function calls in FBSL Variants that have the same names as their respective functions but use neither the parentheses nor the arguments.

 

'''Using pure FBSL's built-in graphics functions:'''

#DEFINE WM_RBUTTONDOWN 516

#DEFINE WM_CLOSE 16

FBSL.RELEASEDC(ME, FBSL.GETDC)

END SELECT

{{out}} [[File:FBSL_RC_Bitmap.PNG]]

=={{header|Forth}}==

This creates bitmaps on the heap (they may be deallocated with "FREE").

32-bit or greater cells are assumed, one pixel per cell.

This automatically word-aligns rows, so a separate ''stride'' field is not required.

0000ff constant red

00ff00 constant green

4 3 bitmap value test

red test bfill

=={{header|Fortran}}==

See [[Basic bitmap storage/Fortran]]

 

=={{header|Go}}==

===Standard library===

 

Here's how to use the standard packages to do what this task requires:

 

import (

fmt.Printf("Pixel at %7v has R=%d, G=%d, B=%d\n",

image.Pt(30, 40), redc, greenc, bluec)

{{out}}

<pre>

===DIY===

Not a complete working program. Presented here are just types and functions requested by the task.

//

// For each task, documentation in package main source will list this

}

return p.Rgb(), true

=={{header|Haskell}}==

We implement the <tt>Image</tt> type as an <tt>STArray</tt> so that we can use it in an imperative fashion in the <tt>ST</tt> monad.

 

import Control.Monad

mapImage :: (Color c, Color c') =>

(c -> c') -> Image s c -> ST s (Image s c')

 

This module provides an instance of <tt>Color</tt>.

 

import Bitmap

toRGBImage :: Color c => Image s c -> ST s (Image s RGB)

toRGBImage = mapImage $ f . luminance

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

The language has a built-in window data type with associated graphics primitives. A bitmap is just a window that isn't visible on-screen at the moment.

return open("bitmap", "g", "canvas=hidden",

"size="||width||","||height)

procedure getpixel(w,x,y)

return Pixel(w,x,y)

=={{header|J}}==

A number of addon packages are available for J that work with common image formats (including PPM), but here we will show a basic bitmap storage type as per the task description.

 

'''Solution:'''

fillRGB=: makeRGB }:@$

setPixels=: (1&{::@[)`(<"1@(0&{::@[))`]}

 

'''Examples:'''

 

myimg=: 255 makeRGB 5 8 NB. create a white bitmap with height 5 and width 8

myimg=: 127 makeRGB 5 8 NB. create a gray bitmap with height 5 and width 8

 

}:$ myimg NB. get height and width of the image

 

<code>getPixels</code> and <code>setPixels</code> are generalized to set and get lists/arrays of pixels.

 

 

NB. create 10 by 10 block of magenta pixels in the middle of a 300 by 300 green image

 

NB. get pixel color for 10x10 block offset from magenta block

 

To display the image in a window at any point for verification:

 

viewRGB=: [: viewrgb 256&#.

 

 

Note that height comes before width here. This is inconsistent with marketing of display resolutions, but matches J's treatment of dimensions.

=={{header|Java}}==

Solution {{libheader|AWT}}

import java.awt.Graphics;

import java.awt.Image;

return image;

}

 

Test Program {{libheader|JUnit}}

 

import java.awt.Color;

assertEquals(Color.CYAN, c2);

}

=={{header|JavaScript}}==

 

JavaScript can interact with a drawing context using the HTML5 Canvas API.

 

// Set up the canvas

var canvas = document.createElement("canvas"),

ctx.fillStyle = "black";

ctx.fillRect(width / 2, height / 2, 1, 1);

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

'''Using packages''' ([https://github.com/JuliaImages/Images.jl Images.jl], [https://github.com/JuliaGraphics/Colors.jl Colors.jl]):

 

Base.hex(p::RGB{T}) where T = join(hex(c(p), 2) for c in (red, green, blue))

img[2, 3] = cfore

println("\nImage with a pixel set for foreground color:")

 

{{out}}

FF00FF FF00FF FF00FF FF00FF FF00FF

FF00FF FF00FF FF00FF FF00FF FF00FF</pre>

=={{header|KonsolScript}}==

Var:Number shape;

Screen:Render()

}

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.awt.Color

println(if (c2 == Color.cyan) "cyan" else "unknown")

}

 

{{out}}

The color of the pixel at (120, 120) is cyan

</pre>

=={{header|Lingo}}==

img = image(640, 480, 32)

 

 

-- Changes the color of the pixel at point (320, 240) to black

=={{header|LiveCode}}==

LiveCode has built in support for importing and exporting PBM, JPEG, GIF, BMP or PNG graphics formats

 

-- create an image container box at the center of the current stack window with default properties

create image "test"

-- the next line is copy of the Write a PPM task:

export image "test" to file "~/Test.PPM" as paint -- paint format is one of PBM, PGM, or PPM

=={{header|Lua}}==

===Original===

local bitmap = {}

for i = 1, width do

function Get_Pixel( bitmap, x, y )

return bitmap[x][y]

This can be used like:

Fill_Bitmap( bitmap, { 15, 200, 80 } )

pixel = Get_Pixel( bitmap, 20, 25 )

===Alternate===

A more object-oriented and extensible approach for easier re-use elsewhere.

new = function(self, width, height)

local instance = setmetatable({ width=width, height=height }, self)

}

Bitmap.__index = Bitmap

Usage:

 

-- default pixel representation is 32-bit packed ARGB on [0,255]

print(string.format("pixel at 0,0 = %s", bitmap:get(0,0)))

print(string.format("pixel at 1,1 = %s", bitmap:get(1,1)))

Caveat: Just be aware that ''as currently written'' the storage of complex types are referenced rather than copied. So, for example, using the clear() method with a table representing an RGB-tuple, will store the same identical reference throughout the bitmap - so direct modification of any one pixel's internal components would affect all other pixels as well. You should override the clear() method as appropriate to better support your desired pixel representation if this is not the behavior you desire.

{{out}}

pixel at 1,1 = green

pixel at 2,2 = blue</pre>

=={{header|M2000 Interpreter}}==

The easy way is to make a function to return an object with all functions on it, for specific image. We have to make the image in a way to render it to screen. The render statement get data in a string using a header of 12 characters (24 bytes). Raster lines are in down-top order. So last raster line is the top one. Also RGB is BGR in this data structure. Raster lines has to be aligned proper, so we may have add some bytes.

 

===P3 ppm===

\ Bitmap width in pixels, height in pixels

\ Return a group object with some lambda as members: SetPixel, GetPixel, Image$

copy 500*twipsx,50*twipsy use A1.Image$()

 

 

===P6 ppm===

Need Version 9.4, Rev >=19

Module P6 {

Function Bitmap {

}

P6

Export using M2000 code for ppm is slower than using internal jpg and bmp encoders. Jpg encoder has a 100% quality, and because this image is black and white we get the best compression. Time 0.304sec is for three exports, two jpg and one bmp.

 

0.3040944sec

</pre>

=={{header|Maple}}==

return Array(1..width, 1..height, 1..3);

end proc:

end do:

return rgb:

{{Out|Use}}

<pre>a := allocateImg(200,200);

#Output the image

ImageTools:-Embed(ImageTools:-Create(a))</pre>

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

In Mathematica 7/8:

img = ReplacePart[img, {1, 1, 1} -> {0, 0, 1}];

In Mathematica 9:

img = ReplacePixelValue[img, {1, 1} -> {0, 0, 1}];

=={{header|MATLAB}}==

Save this in a file named Bitmap.mat in a folder named @Bitmap in your MATLAB root directory.

%Bitmap class

%

end %methods

end %classdef

 

Sample Usage:

>> img = Bitmap(20,30);

>> img.fill([30 30 150]);

>> img.save()

Save Complete

=={{header|MAXScript}}==

 

MAXScript provides a built-in Bitmap class.

 

Filling the image with a single colour can be accomplished at creation time by setting the color property.

 

Use setPixels to set the colour of a pixel. This function takes an array of colours and is optimised to set the colours of a whole row of pixels.

 

Use getPixels to retrieve the colour of a pixel. As with setPixels, this function is optimised to retrieve one row at a time as an array of colour values.

 

=={{header|Modula-3}}==

Since this code is for use with other tasks, it uses an interface as well as the implementation module.

 

TYPE UByte = BITS 8 FOR [0 .. 16_FF];

PROCEDURE SetPixel(VAR pic: T; point: Point; color: Pixel);

 

 

PROCEDURE NewImage(height, width: UByte): T RAISES {BadImage} =

BEGIN

=={{header|Nim}}==

Luminance* = uint8

Index* = int

img[1, 2] = color(255, 0, 0)

img[3, 4] = img[1, 2]

=={{header|OCaml}}==

 

let all_channels =

let kind = Bigarray.int8_unsigned

r_channel,

g_channel,

 

and here is the type of the raster image this function returns:

A more naive form would be this one:

 

let r_channel, g_channel, b_channel =

let kind = Bigarray.int8_unsigned

(r_channel,

g_channel,

 

Here are the functions to fill with a color and to set one given pixel:

 

Bigarray.Array2.fill r_channel r;

Bigarray.Array2.fill g_channel g;

Bigarray.Array2.fill b_channel b;

 

(fun x y ->

r_channel.{x,y} <- r;

g_channel.{x,y} <- g;

b_channel.{x,y} <- b;

 

(fun x y ->

(r_channel.{x,y},

g_channel.{x,y},

b_channel.{x,y})

 

we can overload these functions to make some bound checks:

 

let _, r_channel,_,_ = img in

let width = Bigarray.Array2.dim1 r_channel

if (y < 0) || (y >= height) then invalid_arg "y out of bounds";

get_pixel_unsafe img x y;

 

and a function to get the dimensions:

 

let width = Bigarray.Array2.dim1 r_channel

and height = Bigarray.Array2.dim2 r_channel in

=={{header|Octave}}==

In Octave, images are matrix. A grayscale W×H image is stored as a W×H matrix, and RGB W×H image is stored as a W×H×3 image. Possible levels depend on the class of the storage: if it is double, the intensity is a floating point double number between 0 and 1; if it is uint8, the intensity is from 0 to 255; if it is uint16, the intensity is between 0 and 65535.

 

% and intensity from 0 to 255; black (all zeros)

im(:,:,1) = 255; % set R to 255

% at W/3, H/3

p = im(40,40,:); % or just store it in the vector p, so that

 

We can hide this in helper functions like:

 

im = zeros(w, h, 3, "uint8");

endfunction

g = im(coord(1), coord(2), 2)

b = im(coord(1), coord(2), 3)

 

The only thing to note is that indexing start from 1.

 

im = create_rgb_image(200,200);

for x = 1:128

 

% it seems like saveimage wants double class on [0,1]

=={{header|OxygenBasic}}==

'GENERIC BITMAP

 

 

del m

=={{header|Oz}}==

We first create a 2D array data type as a functor in a file "Array2D.oz":

export

New

 

%% omitted: Clone, Map, Fold, ForAll

 

Based on this, we create a functor "Bitmap.oz":

%% http://www.mozart-oz.org/home/doc/mozart-stdlib/wp/qtk/html/node38.html

 

 

%% Omitted: MaxValue, ForAllPixels, Transform

 

Some functions that are used in other tasks were omitted. See here for the complete module definitions: [[Basic bitmap storage/Oz]]

=={{header|Pascal}}==

uses crt, { GetDir }

graph; { function GetPixel }

end; { with bmpInfoHeader, bmpFileHeader }

end; { procedure }

=={{header|Perl}}==

{{libheader|Imlib2}}

 

use strict;

my $img = Image::Imlib2->new_using_data(200, 200, $col x (200 * 200));

 

=={{header|Phix}}==

Copy of [[Bitmap#Euphoria|Euphoria]]

=={{header|PHP}}==

public $data;

public $w;

$b->fill(2, 2, 18, 18, array(240,240,240));

$b->setPixel(0, 15, array(255,0,0));

=={{header|PicoLisp}}==

For time critical applications this would be done with inline-C in PicoLisp,

but especially for small bitmaps the following makes sense.

(setq *Ppm (make (do 90 (link (need 120)))))

 

# Get the color of a pixel

(de ppmGetPixel (Ppm X Y)

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

/* Declaration for an image, suitable for BMP files. */

declare image(0:500, 0:500) bit (24) aligned;

 

declare image(*,*) controlled bit (24) aligned;

=={{header|Processing}}==

bitmap.beginDraw();

bitmap.background(255, 0, 0); // Fill bitmap with red rgb color

color c = get(50, 50); // Get the color of same pixel

if(b == c) print("Color changed correctly"); // Verify

=={{header|Prolog}}==

:- module(bitmap, [

new_bitmap/3,

replace0(X,Row,RGB,New_Row),

replace0(Y,Pixels,New_Row,New_Pixels).

=={{header|PureBasic}}==

CreateImage(1,w,h)

;1 is internal id of image

; check if we set it right (should be 255)

Debug Blue(Point(10,10))

=={{header|Python}}==

See [[Basic bitmap storage/Python]]

 

=={{header|R}}==

R can write to most bitmap image formats by default (mostly for the purpose of saving graphs), however there is no built-in way of manipulating images. The pixmap package reads, writes and manipulates portable bitmap file types: PBM, PGM, PPM.

See also, the image function, and the rimage and ReadImage packages, which use libjpeg to read JPEG and PNG files.

getClass("pixmapIndexed", package=pixmap)

pixmapIndexed

pmcol[i,j]

}

=={{header|Racket}}==

#lang racket

 

;; to view the final image:

bm

=={{header|Raku}}==

(formerly Perl 6)

class Bitmap {

has UInt ($.width, $.height);

$b.set-pixel( 7, 5, Pixel.new( R => 100, G => 200, B => 0) );

 

 

Thanks to the <tt>rw</tt> trait on the <tt>pixel</tt> method, we don't actually need to define two separate methods, <tt>set-pixel</tt> and <tt>get-pixel</tt>, but that is an explicit requirement of the task. (Beware your presuppositions! In Raku, accessors only determine identity, not use. In particular, identity is considered orthogonal to lvalue/rvalue context.)

=={{header|RapidQ}}==

 

The commands to draw on the canvas are in the procedure PaintCanvas, which is executed each time the canvas need to be (re)painted.

 

 

CREATE form AS QForm

END SUB

 

=={{header|REXX}}==

===version 1===

 

The image (raster) created was also written to a file &nbsp; ('''image.PPM''') &nbsp; to show verification of the image.

{{out|output}}

<pre>

===version 2===

This program actually creates a BMP file

* Draw a picture from pixels

* 16.06.2014 Walter Pachl

i=w3*(y-1)+3*(x-1)

say 'color at pixel' x'/'y'='c2x(substr(pic,i+1,3))

{{out}}

<pre>lend: 600 -> 58020000 => 600

 

and have a look at the file pic.bmp created by this program</pre>

=={{header|Ruby}}==

I haven't been able to find any kind of package for manipulating bitmap images, so let's roll one

def initialize(red, green, blue)

unless red.between?(0,255) and green.between?(0,255) and blue.between?(0,255)

end

alias_method :set_pixel, :[]=

=={{header|Rust}}==

pub struct Rgb {

pub r: u8,

}

assert_eq!(Some(&Rgb::new(0, 155, 20)), image.get(3, 4));

=={{header|Scala}}==

===Java translation===

{{trans|Java}}

import java.awt.Color

 

def setPixel(x:Int, y:Int, c:Color)=image.setRGB(x, y, c.getRGB())

def getPixel(x:Int, y:Int)=new Color(image.getRGB(x, y))

Usage:

img.fill(Color.CYAN)

img.setPixel(5, 5, Color.BLUE)

assert(img.getPixel(5,5)==Color.BLUE)

assert(img.width==50)

===Scala idiom===

A more Scalesque version could be with the use of its idiom:

{{Out}}

Best experienced in your browser [https://scastie.scala-lang.org/cy2uZB9DSaWVMnZjTJgQNA with Scastie (remote JVM)].

import java.awt.Color

 

assert(img0.height == 60)

println("Tests successfully completed with no errors found.")

=={{header|Scheme}}==

{{Works with|Scheme|R<math>^5</math>RS}}

 

Definitions of list procedures:

(if (= length 0)

(list)

(if (= element 1)

(car list)

Definitions of image procedures:

(if (= rows 0)

(list)

 

(define (image-get image column row)

Definitions of some colours:

(define *white* (list 255 255 255))

(define *red* (list 255 0 0))

(define *green* (list 0 255 0))

This creates a small image with a black background and a single blue pixel:

(image-fill! image *black*)

(image-set! image 2 1 *blue*)

(display image)

{{out}}

=={{header|Seed7}}==

The types and functions requested are predefined in the libraries

*The color of a pixel can be retrieved with [http://seed7.sourceforge.net/libraries/draw.htm#getPixelColor(in_PRIMITIVE_WINDOW,in_integer,in_integer) getPixelColor].

 

include "draw.s7i";

 

myColor := getPixelColor(myPixmap, 20, 30);

writeln(myColor.redLight <& " " <& myColor.greenLight <& " " <& myColor.blueLight);

=={{header|SequenceL}}==

 

newBitmap: int * int -> RGB(2);

redCenter := setColorAt(filledGreen, width / 2, height / 2, lightRed);

in

 

{{out}}

<pre>cmd:> main.exe

(B:51,G:51,R:255)</pre>

=={{header|Smalltalk}}==

 

 

=={{header|Tcl}}==

{{libheader|Tk}}

package require Tk

namespace path ::tcl::mathfunc ;# for [max] function

setPixel $img green {40 40}

 

=={{header|TI-89 BASIC}}==

 

TI-89 BASIC does not have user-defined data structures. The Rosetta Code tasks which use this image type have instead been implemented using the TI-89's graph screen.

=={{header|UNIX Shell}}==

{{works with|ksh93}}

integer r g b

function to_s {

b.setpixel 2 1 "$(color.black)"

echo "$(b.getpixel 0 0)"

 

{{out}}

255 0 0 0 255 0 0 0 255

255 255 0 255 255 255 0 0 0</pre>

=={{header|Vedit macro language}}==

 

An edit buffer is used to store pixel data. In order to allow unlimited image size, a temporary file (here pixel.data) can be assosicated to the buffer. You could directly open the image file you are creating (as in the task [[Dragon_curve#Vedit_macro_language|Dragon_curve]], but here we first create just the plain pixel data so that the required image file format can be decided later.

#12 = 300 // Height of the image

 

#6 = Cur_Char(1)

#7 = Cur_Char(2)

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

 

<System.Runtime.InteropServices.StructLayout(LayoutKind.Explicit)> _

Public Structure Rgb

End Sub

 

 

 

Private m_pixels() As Rgb

End Function

 

=={{header|Wren}}==

{{libheader|DOME}}

The above library's ImageData class fits the bill here (version 1.3.0 or later).

import "dome" for Window

 

 

static draw(alpha) {}

 

{{out}}

=={{header|Xojo}}==

 

Return New Picture(width, height)

End Function

p.RGBSurface.Pixel(x, y) = pColor

End Sub

=={{header|XPL0}}==

[[File:BitmapXPL0.png|right]]

def Width=180, Height=135, Color=$123456;

int X, Y;

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

SetVid(3); \restore display to normal text mode

 

=={{header|zkl}}==

This solution creates a PPM image. No error checking or clipping.

fcn init(width,height){

sz:=width*height*3;

out.close();

}

ppm.fill(0x00FF88);

foreach x in ([50..200]){ ppm[x,50]=0xff|00|00; } // horizontal red line

 

{{out}}

<pre>

...

</pre>