Bitmap: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
m (→{{header|Wren}}: Changed to Wren S/H) |
|||
| (15 intermediate revisions by 5 users not shown) | |||
Line 425:
Because this code will be used in other tasks, I have separated it into "static" and "dynamic" source files. The former is the equivalent of an "interface" file in some other languages, and the latter is equivalent of an "implementation" file. I included some test code that gets compiled if you put the correct option on the compiler command line.
This file should be called <code>bitmap_task.sats</code>.
<syntaxhighlight lang="ats">
#define ATS_PACKNAME "Rosetta_Code.bitmap_task"
Line 444 ⟶ 445:
vtypedef pixmap (a : t@ype, w : int, h : int) =
[p : addr] pixmap (a, w, h, p)
(* A shorthand for a pixmap with "some" width and height, and with its
pixel storage at "some" address. *)
vtypedef pixmap (a : t@ype) = [w, h : int] pixmap (a, w, h)
(* A shorthand for a pixmap with "some" POSITIVE width and POSITIVE
height, and with its pixel storage at "some" address. *)
vtypedef pixmap1 (a : t@ype) = [w, h : pos] pixmap (a, w, h)
(*------------------------------------------------------------------*)
Line 453 ⟶ 462:
set or get individual pixels, if the pixmap is not already fully
initialized by some other means (such as "fill" or "load"). *)
fn {}
pixmap_width :
{a : t@ype}
{w, h : int}
(!pixmap (a, w, h)) -<> size_t w
fn {}
pixmap_height :
{a : t@ype}
{w, h : int}
(!pixmap (a, w, h)) -<> size_t h
fn {a : t@ype}
Line 462 ⟶ 483:
(array_v (a, p, w * h) | size_t w, size_t h, ptr p) ->
pixmap (a, w, h, p)
fn {a : t@ype}
pixmap_unmake :
(* Essentially the reverse of pixmap_make_array. Temporarily treat a
pixmap as an array. The array will be organized as rows from left
to right, with the rows themselves going from top to bottom. Thus
an index would be i = x + (y * w). *)
{w, h : int} {p : addr}
pixmap (a, w, h, p) ->
@(array_v (a, p, w * h) | size_t w, size_t h, ptr p)
prfn
pixmap_prove_index_bounds :
(* A proof that i = x + (y * w) is within bounds of the array
returned by pixmap_unmake. *)
{w, h : int}
{x, y : nat | x < w; y < h}
() -<prf>
[0 <= x + (y * w);
x + (y * w) < w * h]
void
fn {a : t@ype}
Line 600 ⟶ 642:
overload dump with pixmap_dump
overload load with pixmap_load
overload width with pixmap_width
overload height with pixmap_height
(*------------------------------------------------------------------*)
(* Here is a type for 24-bit RGB data.
written as "pixmap (rgb24, w, h, p)".
There are, though you cannot see it here (they are in the dynamic
file), default implementations of pixmap$pixels_dump<rgb24> and
pixmap$pixels_load<rgb24>. These implementations are for dumping
raw data in PPM format. *)
(*
fact, a triple of uint8, but we hide this fact, so the template
system will not confuse the type with other triples of uint8. It is
fn {tk : tkind}
rgb24_make_uint_uint_uint :
(g0uint tk, g0uint tk, g0uint tk) -<> rgb24
fn {tk : tkind}
rgb24_make_int_int_int :
(g0int tk, g0int tk, g0int tk) -<> rgb24
fn {}
rgb24_make_tuple : @(uint8, uint8, uint8) -<> rgb24
fn {}
rgb24_values : rgb24 -<> @(uint8, uint8, uint8)
overload rgb24_make with rgb24_make_uint_uint_uint
overload rgb24_make with rgb24_make_int_int_int
overload rgb24_make with rgb24_make_tuple
(*------------------------------------------------------------------*)
</syntaxhighlight>
This file should be called <code>bitmap_task.dats</code>.
<syntaxhighlight lang="ats">
(*------------------------------------------------------------------*)
Line 647 ⟶ 711:
assume pixmap (a, w, h, p) = _pixmap (a, w, h, p)
(* Another way is to use casts. *)
(*------------------------------------------------------------------*)
implement {}
pixmap_width pix =
case+ pix of _pixmap record => record.w
implement {}
pixmap_height pix =
case+ pix of _pixmap record => record.h
implement {a}
pixmap_make_array (pf | w, h, p) =
_pixmap @{pf = pf | w = w, h = h, p = p}
implement {a}
pixmap_unmake pix =
case+ pix of
| ~ _pixmap @{pf = pf | w = w, h = h, p = p} => @(pf | w, h, p)
primplement
pixmap_prove_index_bounds {w, h} {x, y} () =
let
prval () = mul_gte_gte_gte {y, w} ()
prval () = mul_gte_gte_gte {h - (y + 1), w} ()
in
end
implement {a}
Line 726 ⟶ 813:
in
end
implement {a} {tk}
Line 752 ⟶ 825:
stadef i = x + (y * w)
prval () =
prval () = prop_verify {0 <= i && i < n} ()
Line 783 ⟶ 856:
stadef i = x + (y * w)
prval () =
prval () = prop_verify {0 <= i && i < n} ()
Line 860 ⟶ 933:
end
end
(*------------------------------------------------------------------*)
assume rgb24 = @(uint8, uint8, uint8)
implement {tk}
rgb24_make_uint_uint_uint (r, g, b) =
let
(* The prelude tends to miss implementations for type conversions
to uint8, so let us at least implement conversion from uint to
uint8. (I do not wish to use a general unsafe cast, because
that sort of code has caused me bugs before. C does not always
know how to do a type conversion correctly.) The ats2-xprelude
package has a much more complete set of implementations
(generated en masse by m4 macros), but for this task I am
avoiding such dependencies. *)
implement
g0uint2uint<uintknd,uint8knd> i =
let
extern castfn g0uint2uint_uint_uint8 : uint -<> uint8
in
g0uint2uint_uint_uint8 i
end
in
rgb24_make_tuple @(g0u2u r, g0u2u g, g0u2u b)
end
implement {tk}
rgb24_make_int_int_int (r, g, b) =
let
(* See the comment in rgb24_make_uint_uint_uint. *)
implement
g0int2uint<intknd,uint8knd> i =
let
extern castfn g0int2uint_int_uint8 : int -<> uint8
in
g0int2uint_int_uint8 i
end
in
rgb24_make @(g0i2u r, g0i2u g, g0i2u b)
end
implement {}
rgb24_make_tuple tup = tup
implement {}
rgb24_values rgb = rgb
(*------------------------------------------------------------------*)
Line 888 ⟶ 1,008:
I have the data stored as "4.2.07.raw". *)
let
val failure_color = rgb24_make (0xFF, 0x00, 0x00)
val @(pfgc1 | pix1) = pixmap_make<rgb24> (i2sz 512, i2sz 512)
Line 918 ⟶ 1,037:
val outf = fileref_open_exn ("4.2.07.raw.dumped", file_mode_w)
val success = dump<rgb24> (
val () = fileref_close outf
val- true = success
Line 945 ⟶ 1,064:
<pre>$ patscc -std=gnu2x -g -O2 -DATS_MEMALLOC_LIBC -DATS BITMAP_TASK_TEST bitmap_task.sats bitmap_task.dats
$ ./a.out</pre>
You should end up with a copy of the data in a file named <code>4.2.07.raw.dumped</code>.
=={{header|AutoHotkey}}==
Line 1,749 ⟶ 1,867:
bmp.Free;
end.</syntaxhighlight>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
This is a pure Delphi example using standard Delphi controls and libraries that already have raster and bitmap objects and operations built in.
Bascially, Delphi has a powerful set of tools for manipulating graphic objects. All graphic objects including Screens, Printers, Windows or Bitmaps, have a property called a "Canvas." As a consequence, the same code can draw on the Screen, the Printer, a Window or a Bitmap. A Canvas has powerful function that allow you to draw pixels, lines, rectangles, circles, elispes, polygons and text on any graphic object. The code below demonstrates many of the function available in a canvas.
[[File:DelphiBitmaps.png|frame|none]]
<syntaxhighlight lang="Delphi">
procedure ShowBitmapFunctions(Image: TImage);
{Code to demonstrate some of the main features the Delphi "TCanvas" object}
var I,X,Y: integer;
var C: TColor;
begin
{Draw red rectangle with 3 pixels wide lines}
Image.Canvas.Pen.Color:=clRed;
Image.Canvas.Pen.Width:=3;
Image.Canvas.Rectangle(50,50,500,300);
{Flood fill rectangle blue}
Image.Canvas.Brush.Color:=clBlue;
Image.Canvas.FloodFill(55,55,clRed,fsBorder);
{Draw random dots on the screen}
for I:=1 to 1000 do
begin
X:=trunc((Random * 450) + 50);
Y:=trunc((Random * 250) + 50);
C:=RGB(Random(255),Random(255),Random(255));
{draw 9 pixels for each point to make dots more visible}
Image.Canvas.Pixels[X-1,Y-1]:=C;
Image.Canvas.Pixels[X ,Y-1]:=C;
Image.Canvas.Pixels[X+1,Y-1]:=C;
Image.Canvas.Pixels[X-1,Y ]:=C;
Image.Canvas.Pixels[X ,Y ]:=C;
Image.Canvas.Pixels[X+1,Y ]:=C;
Image.Canvas.Pixels[X-1,Y+1]:=C;
Image.Canvas.Pixels[X ,Y+1]:=C;
Image.Canvas.Pixels[X+1,Y+1]:=C;
end;
{Draw lime-green line from corner to cornder}
Image.Canvas.Pen.Color:=clLime;
Image.Canvas.MoveTo(50,50);
Image.Canvas.LineTo(500,300);
{Sample pixel color at 51,51}
C:=Image.Canvas.Pixels[51,51];
{Display the color value }
Image.Canvas.Brush.Color:=clAqua;
Image.Canvas.Font.Size:=25;
Image.Canvas.Font.Color:=clRed;
Image.Canvas.TextOut(5,5,IntToHex(C,8));
{Tell Delphi to update the Window}
Image.Repaint;
end;
</syntaxhighlight>
{{out}}
<pre>
Elapsed Time: 39.038 ms.
</pre>
=={{header|E}}==
Line 3,453 ⟶ 3,634:
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.
<syntaxhighlight lang="maxscript">local myPixel = getPixels myBitmap [256, 256] 1</syntaxhighlight>
=={{header|MiniScript}}==
This GUI implementation is for use with [http://miniscript.org/MiniMicro Mini Micro].
<syntaxhighlight lang="miniscript">
// MiniMicro version of MiniScript has all the
// necessary methods built-in to complete this task.
width = 256
height = 256
colr = color.aqua
// Create the image with specified width/heigh. With
// no parameters, it defaults width/height to 64 and
// color to black
img = Image.create(width, height, colr)
// Create a diagonal line of multiple colors. Uses
// Cartesian coordinates so (0, 0) is lower left corner.
for i in range(0, 255)
img.setPixel i, i, color.rgb(i, i, i)
end for
// Get pixel color as RGBA hex values
print "Color at pixel (100, 100): " + img.pixel(100, 100)
print "Color at pixel (0, 0): " + img.pixel(0, 0)
print "Color at pixel (127, 127): " + img.pixel(127, 127)
print "Color at pixel (255, 255): " + img.pixel(255, 255)
// Display the image, resizing it to 127 x 127
gfx.drawImage img, 0, 0, 127, 127
// Save the file - accepted file extensions:
// tga, jpg, jpeg, and png (retains transparency)
// Optional third parameter is JPG compression quality.
file.saveImage "/usr/test.png", img
</syntaxhighlight>
=={{header|Modula-3}}==
Since this code is for use with other tasks, it uses an interface as well as the implementation module.
Line 4,216 ⟶ 4,433:
=={{header|Python}}==
See [[Basic bitmap storage/Python]]
=={{header|QBasic}}==
{{works with|QBasic|1.1}}
<syntaxhighlight lang="qbasic">SUB establecePixel (x AS INTEGER, y AS INTEGER, c AS INTEGER)
PSET (x, y), cyan
END SUB
SUB rellenar (c AS INTEGER)
SHARED w, h
LINE (0, 0)-(w / 3, h / 3), red, BF
END SUB
SCREEN 13
w = 320: h = 200
CONST cyan = 3, red = 4
rellenar (12)
CALL establecePixel(10, 10, cyan)
LOCATE 12
PRINT "pixel 10,10 is "; POINT(10, 10)
PRINT "pixel 20,20 is "; POINT(20, 10)</syntaxhighlight>
=={{header|R}}==
{{libheader|pixmap}}
Line 4,354 ⟶ 4,593:
The image (raster) created was also written to a file ('''image.PPM''') to show verification of the image.
<syntaxhighlight lang="rexx">/*REXX program demonstrates how to process/display
sWidth = 500; sHeight= 500 /*the screen width and height in pixels*/
Call RGBfill
binV = x2b(hexV) /* " binary " " " " */
hex3V = left(hexV,2) substr(hexV,3,2) right(hexV,2)
Say xy ' pixel in binary: ' bin3V /*show again,but with spaces. */
Say xy ' pixel in hex: ' hex3V /*show again,but with spaces. */
Call PPMwrite outFN,sWidth,sHeight /*create a PPM (output) file */
/* ?¦¦¦¦¦¦¦¦ not part of this task.*/
Say 'The file ' outFN'.PPM was created.' /*inform user */
/*---------------------------------------------------------------------*/
RGBget: Parse arg px,py; Return pixel.px.py /*get a pixel's color. */
RGBset: Parse arg px,py,psep; pixel.px.py=psep; Return /*set a pixel */
/*---------------------------------------------------------------------*/
PPMwrite: Parse arg oFN,width,height
oFID= oFN'.PPM' /* fileID
sep='9'x; /* separator
maxcol=255
Call charout oFID,,1
Call charout oFID,'P6'width||sep||height||sep||maxcol||sep /* header */
Do i=1 To width
Do j=1 To height;
Call charout oFID,pixel.i.j
End
End
Call charout oFID /* close the output file just to be safe */
Return</syntaxhighlight>
{{out|output}}
<pre>
Line 5,131 ⟶ 5,376:
{{libheader|DOME}}
The above library's ImageData class fits the bill here (version 1.3.0 or later).
<syntaxhighlight lang="
import "dome" for Window
Line 5,170 ⟶ 5,415:
Color (#29ADFFFF)
</pre>
=={{header|Xojo}}==
| |||