Bitmap/Write a PPM file: Difference between revisions

{{task|Raster graphics operations}}

 

 

(Read [[wp:Netpbm_format|the definition of PPM file]] on Wikipedia.)

<br><br>

=={{header|11l}}==

{{trans|Python}}

 

Byte r, g, b

 

print(bitmap.writeppmp3())

 

 

{{out}}

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

{{libheader|Action! Bitmap tools}}

 

PROC SaveHeader(RgbImage POINTER img

63 31 127 127 31 63 127 63 31

</pre>

=={{header|Ada}}==

with Ada.Streams.Stream_IO; use Ada.Streams.Stream_IO;

 

procedure Put_PPM (File : File_Type; Picture : Image) is

 

=={{header|Aime}}==

file f;

 

} while ((i += 16) < w);

} while ((j += 1) < h);</syntaxhighlight>

=={{header|Applesoft BASIC}}==

110 H = 8

120 BA = 24576

500 R = C - INT (C / 256) * 256:B = INT (C / 65536):G = INT (C / 256) - B * 256:A = BB + X * 3 + Y * W * 3: POKE A,R: POKE A + 1,G: POKE A + 2,B: RETURN

600 FOR Y = 0 TO H - 1: FOR X = 0 TO W - 1: GOSUB 500: NEXT X,Y: RETURN</syntaxhighlight>

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L|45}}

cyan := color(0,255,255) ; r,g,b

cyanppm := Bitmap(10, 10, cyan) ; width, height, background-color

 

=={{header|AWK}}==

BEGIN {

split("255,0,0,255,255,0",R,",");

close(outfile);

}</syntaxhighlight>

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

{{works with|BBC BASIC for Windows}}

Height% = 200

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

= col%</syntaxhighlight>

=={{header|BQN}}==

4 8

255

"small.ppm" •file.Bytes bytes_ppm</syntaxhighlight>

{{trans|C}}

800 800

255

image_ppm ← @ + ⥊ > {256|𝕨‿𝕩‿(𝕨×𝕩)}⌜˜ ↕800

"first_bqn.ppm" •file.Bytes header_ppm ∾ image_ppm</syntaxhighlight>

=={{header|C}}==

 

This is one file program which writes one color in each step :

#include <stdio.h>

 

This program writes whole array in one step :

 

 

int main()

Interface:

 

 

Implementation:

 

 

void output_ppm(FILE *fd, image img)

(void) fflush(fd);

}</syntaxhighlight>

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

This implementation uses a StreamWriter to write the header in text, then writes the pixel data in binary using a BinaryWriter.

using System.IO;

class PPMWriter

}

}</syntaxhighlight>

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

{{trans|C}}

 

int main() {

constexpr auto dimx = 800u, dimy = 800u;

 

 

for (auto j = 0u; j < dimy; ++j)

for (auto i = 0u; i < dimx; ++i)

}</syntaxhighlight>

 

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

 

(with-open-file (stream filename

:element-type '(unsigned-byte 8)

(write-byte blue stream)))))))

filename)</syntaxhighlight>

=={{header|D}}==

The Image module contains a savePPM6 function to save binary PPM images.

=={{header|Delphi}}==

Helper class to enable bitmap export to ppm.

program btm2ppm;

 

end.

</syntaxhighlight>

=={{header|E}}==

 

The code for this task is incorporated into [[Basic bitmap storage#E]].

=={{header|Erlang}}==

Writes a bitmap to PPM file. Uses 24 bit color depth (color max value 255).

-module(ppm).

 

 

</syntaxhighlight>

=={{header|Euphoria}}==

{{trans|C}}

constant fn = open("first.ppm","wb") -- b - binary mode

sequence color

 

Procedure writing [[Bitmap#Euphoria|bitmap]] data storage:

integer fn,dimx,dimy

dimy = length(image[1])

close(fn)

end procedure</syntaxhighlight>

=={{header|FBSL}}==

This code converts a Windows BMP to a PPM. Uses FBSL volatiles for brevity.

'''24-bpp P.O.T.-size BMP solution:'''

[[File:FBSLWritePpm.PNG|right]]

 

DIM bmpin = ".\\LenaClr.bmp", ppmout = ".\\Lena.ppm", bmpblob = 54 ' Size of BMP file headers

 

FILEPUT(FILEOPEN(ppmout, BINARY_NEW), ppmdata): FILECLOSE(FILEOPEN)</syntaxhighlight>

=={{header|Forth}}==

s" P6" fid write-line throw

bmp bdim swap

test over write-ppm

close-file throw</syntaxhighlight>

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

It loads <code>rgbimage_m</code> module, which is defined [[Basic bitmap storage#Fortran|here]].

 

use rgbimage_m

 

end program</syntaxhighlight>

=={{header|GAP}}==

# Only P3 format, an image is a list of 3 matrices (r, g, b)

# Max color is always 255

PutPixel(g, 2, 3, [0, 0, 0]);

WriteImage("example.ppm", g);</syntaxhighlight>

=={{header|Go}}==

Code below writes 8-bit P6 format only. See Bitmap task for additional file needed to build working raster package.

 

import (

}</syntaxhighlight>

Demonstration program. Note that it imports package raster. To build package raster, put code above in one file, put code from Bitmap task in another, and compile and link them into a Go package.

 

// Files required to build supporting package raster are found in:

}

}</syntaxhighlight>

=={{header|Haskell}}==

 

module Bitmap.Netpbm(readNetpbm, writeNetpbm) where

where magicNumber = netpbmMagicNumber (nil :: c)

maxval = netpbmMaxval (nil :: c)</syntaxhighlight>

=={{header|J}}==

'''Solution:'''

 

NB. ($x) is height, width, colors per pixel

'''Example:'''

Using routines from [[Basic_bitmap_storage#J|Basic Bitmap Storage]]:

pixellist=: >,{;~i.10

myimg=: ((150 + pixellist) ; 255 0 255) setPixels 0 255 0 makeRGB 600 300

myimg writeppm jpath '~temp/myimg.ppm'

540015</syntaxhighlight>

=={{header|Java}}==

 

See [[Basic_bitmap_storage#Java|Basic Bitmap Storage]] for the <tt>BasicBitmapStorage</tt> class.

 

import java.io.File;

import java.io.FileOutputStream;

}

}</syntaxhighlight>

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

h, w = 50, 70

save("data/bitmapWrite.ppm", img)

save("data/bitmapWrite.png", img)</syntaxhighlight>

=={{header|Kotlin}}==

For convenience, we repeat the code for the class used in the [[Bitmap]] task here.

 

import java.awt.Color

}

}</syntaxhighlight>

=={{header|Lua}}==

===Original===

 

-- helper function, simulates PHP's array_fill function

===Alternate===

Uses the alternate Bitmap implementation [[Bitmap#Alternate|here]], extending it with..

local fp = io.open(filename, "wb")

if fp == nil then return false end

end</syntaxhighlight>

Example usage:

bitmap:clear({255,255,255})

for y = 1, 5 do

end

bitmap:savePPM("lua3x5.ppm")</syntaxhighlight>

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

Added ToFile in group which return the function Bitmap. In this example we export using ToFile and get bytes (unsigned values) from buffer, and we export from outside, using getpixel and convert the RGB value to bytes (color returned as a negative number, so we have to invert before further process it)

===P3 type===

Module Checkit {

Function Bitmap (x as long, y as long) {

 

===P6 type===

Module PPMbinaryP6 {

If Version<9.4 then 1000

 

</syntaxhighlight>

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

=={{header|MATLAB}} / {{header|Octave}}==

G=[0,255,0;255,255,0];

B=[0,0,255;0,0,0];

fwrite(fid,[r,g,b]','uint8');

fclose(fid);</syntaxhighlight>

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

<code>Bitmap</code> is the module from [[Basic_bitmap_storage#Modula-3|Basic Bitmap Storage]].

 

IMPORT Bitmap, Pathname;

 

END PPM.</syntaxhighlight>

 

IMPORT Bitmap, Wr, FileWr, Pathname;

 

=={{Header|Nim}}==

import streams

 

=={{Header|OCaml}}==

 

let width = Bigarray.Array2.dim1 r_channel

and height = Bigarray.Array2.dim2 r_channel in

flush oc;

;;</syntaxhighlight>

=={{header|Oz}}==

As a function in the module <code>BitmapIO.oz</code>:

import

Bitmap

end

end</syntaxhighlight>

=={{header|Perl}}==

{{libheader|Imager}}

 

$image = Imager->new(xsize => 200, ysize => 200);

xmax => 150, ymax => 150);

$image->write(file => 'bitmap.ppm') or die $image->errstr;</syntaxhighlight>

=={{header|Phix}}==

Copy of [[Bitmap/Write_a_PPM_file#Euphoria|Euphoria]]. The results may be verified with demo\rosetta\viewppm.exw

constant dimx = 512, dimy = 512

constant fn = open("first.ppm","wb") -- b - binary mode

close(fn)</syntaxhighlight>

The following more general purpose routine is used in several other examples (via include ppm.e):

integer fn = open(filename,"wb"),

dimx = length(image),

close(fn)

end procedure</syntaxhighlight>

=={{header|PHP}}==

Writes a P6 binary file

public $data;

public $w;

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

$b->writeP6('p6.ppm');</syntaxhighlight>

=={{header|PicoLisp}}==

(out File

(prinl "P6")

(prinl 255)

(for Y Ppm (for X Y (apply wr X))) ) )</syntaxhighlight>

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

test: procedure options (main);

declare image (0:19,0:19) bit (24);

end put_integer;

end test;</syntaxhighlight>

=={{header|Prolog}}==

This is an extremely straight forward way to write in Prolog, more complicated methods might use DCGs:

:- module(bitmapIO, [

write_ppm_p6/2]).

usage:

 

:- use_module(bitmap).

:- use_module(bitmapIO).

 

</syntaxhighlight>

=={{header|PureBasic}}==

; Author Roger Rösch (Nickname Macros)

IDFiIe = CreateFile(#PB_Any, file$)

EndIf

EndProcedure</syntaxhighlight>

=={{header|Python}}==

{{works with|Python|3.1}}

 

Extending the example given [[Basic_bitmap_storage#Alternative_version|here]]

# String masquerading as ppm file (version P3)

import io

ppmfileout.close()

</syntaxhighlight>

=={{header|R}}==

{{libheader|pixmap}}

# View the existing code in the library

library(pixmap)

write.pnm(theimage, filename)

</syntaxhighlight>

=={{header|Racket}}==

;P3

(define (bitmap->ppm bitmap output-port)

 

</syntaxhighlight>

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2016-01}}

 

class Bitmap {

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

 

[[File:Ppm-perl6.png‎]]

=={{header|REXX}}==

green = 00ff00 /*define a pixel with the color green. */

parse arg oFN width height color . /*obtain optional arguments from the CL*/

/*stick a fork in it, we're all done. */</syntaxhighlight>

<br><br>

=={{header|Ruby}}==

Extending [[Basic_bitmap_storage#Ruby]]

def values

[@red, @green, @blue]

alias_method :write, :save

end</syntaxhighlight>

=={{header|Rust}}==

use std::io::Write;

use std::fs::File;

}

}</syntaxhighlight>

=={{header|Scala}}==

Extends Pixmap class from task [[Read_ppm_file#Scala|Read PPM file]].

def save(bm:RgbBitmap, filename:String)={

val out=new DataOutputStream(new FileOutputStream(filename))

}

}</syntaxhighlight>

=={{header|Scheme}}==

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

(define (write-image image)

(define (write-row row)

(write-image image)))))</syntaxhighlight>

Example using definitions in [[Basic bitmap storage#Scheme]]:

(image-fill! image *black*)

(image-set! image 400 300 *blue*)

(write-ppm image "out.ppm")</syntaxhighlight>

=={{header|Seed7}}==

include "draw.s7i";

include "color.s7i";

end if;

end func;</syntaxhighlight>

=={{header|Sidef}}==

{{trans|Raku}}

subset UInt < Int {|n| n >= 0 }

subset UInt8 < Int {|n| n ~~ ^256 }

 

%f"palette.ppm".write(b.p6, :raw)</syntaxhighlight>

=={{header|Stata}}==

 

P3 format only, with Mata.

 

void writeppm(name, r, g, b) {

n = rows(r)

writeppm("image.ppm", r, g, b)

end</syntaxhighlight>

=={{header|Tcl}}==

{{libheader|Tk}}

Referring to [[Basic bitmap storage#Tcl]]:

 

proc output_ppm {image filename} {

foreach colour $pixel {puts [expr {$colour & 0xff}]} ;# ==> 255 \n 0 \n 0 \n

close $fh</syntaxhighlight>

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

{{works with|ksh93}}

 

Add the following function to the <tt>Bitmap_t</tt> type

_.to_s > "$1"

}</syntaxhighlight>

Then you can:

# do stuff to b, and save it:

b.write '$HOME/tmp/bitmap.ppm'</syntaxhighlight>

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

 

Return

</pre>

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

 

Dim header As String = String.Format("P6{0}{1}{2}{3}{0}255{0}", vbLf, rasterBitmap.Width, " "c, rasterBitmap.Height)

Dim bufferSize As Integer = header.Length + (rasterBitmap.Width * rasterBitmap.Height * 3)

My.Computer.FileSystem.WriteAllBytes(filepath, bytes, False)

End Sub</syntaxhighlight>

=={{header|Wren}}==

{{libheader|DOME}}

import "dome" for Window, Process

import "io" for FileSystem

 

class Bitmap {

init() {

// write bitmap to a PPM file

for (y in 0..._h) {

for (x in 0..._w) {

var c = pget(x, y)

}

}

Process.exit(0)

}

 

=={{header|XPL0}}==

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

 

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

]</syntaxhighlight>

=={{header|Yabasic}}==

 

wid = 150 : hei = 200

poke #fn, asc("\n")

close #fn</syntaxhighlight>

=={{header|zkl}}==

 

// Read BMP file

-rw-r--r-- 1 craigd craigd 786476 Aug 30 01:31 foo.ppm

</pre>

{{omit from|PARI/GP}}