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|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()

{

int x, y;

/* size of the image */

FILE * fp;

/* comment should start with # */

 

/* fill the data array */

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

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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

myimg writeppm jpath '~temp/myimg.ppm'

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

Extending [[Basic_bitmap_storage#Ruby]]

def values

[@red, @green, @blue]

end

alias_method :write, :save

 

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

for x range 0 to pred(width(aWindow)) do

pixColor := getPixelColor(aWindow, x, y);

end for;

end for;

close(ppmFile);

end if;

 

=={{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|Vedit macro language}}==

 

Return

</pre>

 

{{omit from|PARI/GP}}