Bitmap/Write a PPM file: Difference between revisions

[[Category:Input Output]]

 

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

 

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

//Use a streamwriter to write the text part of the encoding

var writer = new StreamWriter(file);

writer.Close();

//Switch to a binary writer to write the data

writerB.Close();

}

 

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

 

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

 

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

 

implicit none

 

 

 

end do

 

 

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

 

 

end

 

 

 

 

 

 

 

 

=={{header|Lua}}==

 

-- helper function, simulates PHP's array_fill function

end

 

width = (width == nil) and self.width or width

height = (height == nil) and self.height or height

 

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

 

 

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

 

 

 

 

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

 

=={{header|Phix}}==

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

sequence color

end for

end for

printf(fn, "P6\n%d %d\n255\n", {dimx,dimy})

end for

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|PL/I}}==

test: procedure options (main);

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

write file (out) from (ch);

end put_integer;

 

 

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

pub fn write_file(&self, filename: &str) -> std::io::Result<()> {

let path = Path::new(filename);

let header = format!("P6 {} {} 255\n", self.width, self.height);

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

 

struct Pixel {

}

 

has data = []

 

}

 

 

 

func (w < WidthLimit, h < HeightLimit) {

 

method p6 {

}

}

}

 

 

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

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

 

WriteImage;

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

 

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