Bitmap/Write a PPM file: Difference between revisions

{{trans|Python}}

Byte r, g, b

print(bitmap.writeppmp3())

{{out}}

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

{{libheader|Action! Bitmap tools}}

PROC SaveHeader(RgbImage POINTER img

PrintF("Loading %S...%E%E",path3)

Load(path3)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Write_a_PPM_file.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

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

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|Applesoft BASIC}}==

110 H = 8

120 BA = 24576

250 END

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

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

4 8

255

image_ppm ↩ @ + ⥊ image_ppm # deshape, convert to chars (uint8_t)

bytes_ppm ← header_ppm ∾ image_ppm

{{trans|C}}

800 800

255

"

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

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

#include <cstdio>

return EXIT_SUCCESS;

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

(with-open-file (stream filename

:element-type '(unsigned-byte 8)

(write-byte green stream)

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

=={{header|D}}==

=={{header|Delphi}}==

Helper class to enable bitmap export to ppm.

program btm2ppm;

end;

end.

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

'''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|LiveCode}}==

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

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

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

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

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

class Bitmap {

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

}

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

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

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

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

This takes a while to run as DOME needs to build up the file contents in string form before saving them to a PPM file. It is not currently possible to write files a line at a time.

import "dome" for Window, Process

import "io" for FileSystem

}

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