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

</pre>

 

=={{header|Ada}}==

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

 

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

end loop;

Character'Write (Stream (File), LF);

The solution writes the image into an opened file. The file format might fail to work on certain [[OS]]es, because output might mangle control characters like LF, CR, FF, HT, VT etc. The OS might also limit the line length of a text file. In general it is a bad idea to mix binary and text output in one file. This solution uses ''stream I/O'', which should be as portable as possible.

 

=={{header|Aime}}==

file f;

 

16.times(f_bytes, f, drand(255), drand(255), drand(255));

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

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L|45}}

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

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

return 0

}

 

=={{header|AWK}}==

BEGIN {

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

}

close(outfile);

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

{{works with|BBC BASIC for Windows}}

Height% = 200

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

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

=={{header|C}}==

 

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

#include <stdio.h>

 

(void) fclose(fp);

return EXIT_SUCCESS;

 

 

This program writes whole array in one step :

 

 

int main()

printf("OK - file %s saved\n", filename);

return 0;

 

 

Interface:

 

 

Implementation:

 

 

void output_ppm(FILE *fd, image img)

(void) fwrite(img->buf, sizeof(pixel), n, fd);

(void) fflush(fd);

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

writerB.Close();

}

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

 

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

 

(with-open-file (stream filename

:element-type '(unsigned-byte 8)

(write-byte green stream)

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

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

end.

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

 

integer_to_list(Number).

 

=={{header|Euphoria}}==

{{trans|C}}

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

sequence color

end for

end for

 

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

integer fn,dimx,dimy

dimy = length(image[1])

end for

close(fn)

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

WEND

 

=={{header|Forth}}==

s" P6" fid write-line throw

bmp bdim swap

s" red.ppm" w/o create-file throw

test over write-ppm

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

call im%write('fig.ppm')

 

=={{header|GAP}}==

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

# Max color is always 255

PutPixel(g, 2, 2, [255, 255, 255]);

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

=={{header|Go}}==

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

 

import (

}

return f.Close()

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:

fmt.Println(err)

}

=={{header|Haskell}}==

 

module Bitmap.Netpbm(readNetpbm, writeNetpbm) where

stToIO (getPixels i) >>= hPutStr h . toNetpbm

where magicNumber = netpbmMagicNumber (nil :: c)

=={{header|J}}==

'''Solution:'''

 

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

header=. 'P6',LF,(":1 0{$x),LF,'255',LF

(header,,x{a.) fwrite y

'''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'

=={{header|Java}}==

 

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

 

import java.io.File;

import java.io.FileOutputStream;

}

}

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

h, w = 50, 70

 

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

=={{header|Kotlin}}==

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

 

import java.awt.Color

}

}

=={{header|Lua}}==

===Original===

 

-- helper function, simulates PHP's array_fill function

 

example_colorful_stripes():writeP6('p6.ppm')

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

fp:close()

return true

Example usage:

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

for y = 1, 5 do

end

end

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

Checkit

 

 

{{out}}

 

===P6 type===

Module PPMbinaryP6 {

If Version<9.4 then 1000

PPMbinaryP6

 

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

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

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

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

fprintf(fid,'P6\n%i %i\n255\n',size(R));

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

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

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

 

IMPORT Bitmap, Pathname;

PROCEDURE Create(imgfile: Pathname.T; img: Bitmap.T);

 

 

IMPORT Bitmap, Wr, FileWr, Pathname;

BEGIN

 

=={{Header|Nim}}==

import streams

 

for col in 0..<image.w:

image[col, row] = color(0, 0, 255)

 

=={{Header|OCaml}}==

 

let width = Bigarray.Array2.dim1 r_channel

and height = Bigarray.Array2.dim2 r_channel in

output_char oc '\n';

flush oc;

=={{header|Oz}}==

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

import

Bitmap

end

end

=={{header|Perl}}==

{{libheader|Imager}}

 

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

xmin => 50, ymin => 50,

xmax => 150, ymax => 150);

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

end for

end for

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

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

dimx = length(image),

end for

close(fn)

=={{header|PHP}}==

Writes a P6 binary file

public $data;

public $w;

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

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

=={{header|PicoLisp}}==

(out File

(prinl "P6")

(prinl (length (car Ppm)) " " (length Ppm))

(prinl 255)

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

test: procedure options (main);

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

write file (out) from (ch);

end put_integer;

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

maplist(maplist(maplist(put_byte(Output))),Pixels),

close(Output).

 

usage:

 

:- use_module(bitmap).

:- use_module(bitmapIO).

write_ppm_p6('AlmostAllBlack.ppm',AlmostAllBlack).

 

=={{header|PureBasic}}==

; Author Roger Rösch (Nickname Macros)

IDFiIe = CreateFile(#PB_Any, file$)

CloseFile(IDFiIe)

EndIf

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

bitmap.writeppm(ppmfileout)

ppmfileout.close()

=={{header|R}}==

{{libheader|pixmap}}

# View the existing code in the library

library(pixmap)

#Usage

write.pnm(theimage, filename)

=={{header|Racket}}==

;P3

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

;or any other output port

 

=={{header|Raku}}==

(formerly Perl 6)

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

 

class Bitmap {

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

}

 

Converted to a png. (ppm files not locally supported)

 

[[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*/

call charout oFID, _ /*write the image's raster to the file.*/

call charout oFID /*close the output file just to be safe*/

<br><br>

=={{header|Ruby}}==

Extending [[Basic_bitmap_storage#Ruby]]

def values

[@red, @green, @blue]

end

alias_method :write, :save

=={{header|Rust}}==

use std::io::Write;

use std::fs::File;

Ok(())

}

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

}

}

=={{header|Scheme}}==

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

(define (write-image image)

(define (write-row row)

(display 255)

(newline)

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

(image-fill! image *black*)

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

=={{header|Seed7}}==

include "draw.s7i";

include "color.s7i";

close(ppmFile);

end if;

=={{header|Sidef}}==

{{trans|Raku}}

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

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

}

 

=={{header|Stata}}==

 

P3 format only, with Mata.

 

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

n = rows(r)

b = J(6, 6, 255)

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

=={{header|Tcl}}==

{{libheader|Tk}}

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

 

proc output_ppm {image filename} {

binary scan [read $fh 3] c3 pixel

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

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

{{works with|ksh93}}

 

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

_.to_s > "$1"

Then you can:

# do stuff to b, and save it:

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

Next

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

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

 

WriteImage;

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

=={{header|Yabasic}}==

 

wid = 150 : hei = 200

 

poke #fn, asc("\n")

=={{header|zkl}}==

 

// Read BMP file

}

 

{{out}}

<pre>

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

</pre>

{{omit from|PARI/GP}}