Bitmap/Read a PPM file: Difference between revisions

{{task|Raster graphics operations}}

Using the data storage type defined [[Basic_bitmap_storage|on this page]] for raster images, read an image from a PPM file (binary P6 prefered).

'''Task''': Use [[write ppm file]] solution and [[grayscale image]] solution with this one in order to convert a color image to grayscale one.

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

{{trans|Python}}

Byte r, g, b

4 4 4 0 0 0 0 0 0 0 0 0

</pre>

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

Part of the task responsible for conversion from RGB color image into a grayscale image can be found in the module [http://www.rosettacode.org/wiki/Category:Action!_Bitmap_tools#RGB2GRAY.ACT RGB2GRAY.ACT]. File D:PPM6.PPM can be generated by task [http://www.rosettacode.org/wiki/Bitmap/Write_a_PPM_file#Action.21 Bitmap/Write a PPM file].

{{libheader|Action! Bitmap tools}}

{{libheader|Action! Tool Kit}}

PROC DecodeSize(CHAR ARRAY s BYTE POINTER width,height)

45 54 74

</pre>

=={{header|Ada}}==

with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

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

end Get_PPM;</syntaxhighlight>

The implementation propagates Data_Error when the file format is incorrect. End_Error is propagated when the file end is prematurely met. The following example illustrates conversion of a color file to grayscale.

F1, F2 : File_Type;

begin

Close (F2);

end;</syntaxhighlight>

=={{header|AutoHotkey}}==

{{works with | AutoHotkey_L}}

Only ppm6 files supported.

x := img[4,4] ; get pixel(4,4)

y := img[24,24] ; get pixel(24,24)

}

#include bitmap_storage.ahk ; from http://rosettacode.org/wiki/Basic_bitmap_storage/AutoHotkey</syntaxhighlight>

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

{{works with|BBC BASIC for Windows}}

IF f%=0 ERROR 100, "Failed to open input file"

LINE x%*2,y%*2,x%*2,y%*2

ENDPROC</syntaxhighlight>

=={{header|C}}==

It is up to the caller to open the file and pass the handler to the function. So this code can be used in

Interface:

Implementation:

#define PPMREADBUFLEN 256

The following acts as a filter to convert a PPM file read from standard input into a PPM gray image, and it outputs the converted image to standard output (see [[Grayscale image]], [[Write ppm file]], and [[Raster graphics operations]] in general):

#include "imglib.h"

return 0;

}</syntaxhighlight>

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

Tested with [[Write ppm file#C.23|this solution.]]

class PPMReader

{

}

}</syntaxhighlight>

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

The function read-ppm-image reads either a P6 or P3 file depending on the file contents. The package description assumes that you have the [[Basic bitmap storage#Common Lisp]] package.

(in-package #:rgb-pixel-buffer)

</syntaxhighlight>

To read the feep.ppm file as shown on the description page for the ppm format use:

(read-ppm-image "feep.ppm")

</syntaxhighlight>

=={{header|D}}==

The Image module contains a loadPPM6 function to load binary PPM images.

=={{header|Delphi}}==

Class helper for read and write Bitmap's and Ppm's

{{Trans|C#}}

program BtmAndPpm;

end.

</syntaxhighlight>

=={{header|E}}==

def readPPM(inputStream) {

}</syntaxhighlight>

makeGrayscale \

.fromColor(readPPM(<import:java.io.makeFileInputStream>(inputFile))) \

.writePPM(<import:java.io.makeFileOutputStream>(outputFile))

}</syntaxhighlight>

=={{header|Erlang}}==

% This module provides basic operations on ppm files:

% Read from file, create ppm in memory (from generic bitmap) and save to file.

Usage in accordance with Grayscale Task:

Colorful = ppm:read("colorful.ppm"),

Gray = ros_bitmap:convert(ros_bitmap:convert(Colorful, grey), rgb),

ppm:write(Gray, "gray.ppm"),

</syntaxhighlight>

=={{header|Euphoria}}==

function get2(integer fn)

Converting an image to grayscale:

image = read_ppm("image.ppm")

image = to_gray(image)

image = to_color(image)

write_ppm("image_gray.ppm",image)</syntaxhighlight>

=={{header|FBSL}}==

Read a colored PPM file, convert it to grayscale and write back to disk under a different name. Sanity checks are omitted for brevity.

'''24-bpp P6 PPM solution:'''

[[File:FBSLLena.png|right]]

DIM colored = ".\\Lena.ppm", grayscale = ".\\LenaGry.ppm"

FILEPUT(FILEOPEN(grayscale, BINARY_NEW), FILEGET): FILECLOSE(FILEOPEN) ' Save buffer</syntaxhighlight>

=={{header|Forth}}==

pad dup 80 fid read-line throw 0= abort" Partial line"

s" P6" compare abort" Only P6 supported."

test dup bsize test2 dup bsize compare . \ 0 if identical</syntaxhighlight>

=={{header|Fortran}}==

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

(This function is part of module RCImageIO, see [[Write ppm file#Fortran|Write ppm file]])

integer, intent(in) :: u

type(rgbimage), intent(out) :: img

* doing formatted I/O with Fortran is a pain... And unformatted does not mean ''free''; Fortran2003 has ''streams'', but they are not implemented (yet) in GNU Fortran compiler. Here (as in the write part) I've tried to handle the PPM format through formatted I/O. The tests worked but I have not tried still everything.

* comments after the first line are not handled

=={{header|Go}}==

import (

}</syntaxhighlight>

Demonstration program, also demonstrating functions from task [[Grayscale image]]:

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

}

}</syntaxhighlight>

=={{header|Haskell}}==

The definition of <tt>Bitmap.Netpbm.readNetpbm</tt> is given [[Write ppm file|here]].

import Bitmap.RGB

import Bitmap.Gray

writeNetpbm "new.pgm"</syntaxhighlight>

The above writes a PGM, not a PPM, since the image being output is in grayscale. If you actually want a gray PPM, convert the <tt>Image RealWorld Gray</tt> back to an <tt>Image RealWorld RGB</tt> first:

(readNetpbm "original.ppm" :: IO (Image RealWorld RGB)) >>=

stToIO . (toRGBImage <=< toGrayImage) >>=

writeNetpbm "new.ppm"</syntaxhighlight>

=={{header|J}}==

'''Solution:'''<br>

Uses <tt>makeRGB</tt> from [[Basic bitmap storage#J|Basic bitmap storage]].

readppm=: monad define

Using utilities and file from [[Grayscale image#J|Grayscale image]] and [[Write ppm file#J|Write ppm file]].<br>

Writes a gray PPM file (a color format) which is bigger than necessary. A PGM file would be more appropriate.

myimgGray=: toColor toGray myimg

myimgGray writeppm jpath '~temp/myimgGray.ppm'</syntaxhighlight>

=={{header|Julia}}==

{{works with|Julia|0.6}}

rgbimg = load("data/bitmapInputTest.ppm")

greyimg = Gray.(rgbimg)

save("data/bitmapOutputTest.ppm", greyimg)</syntaxhighlight>

=={{header|Kotlin}}==

For convenience, we repeat the code for the class used in the [[Bitmap]] task here and integrate the code in the [[Grayscale image]] task within it.

import java.awt.Color

}

}</syntaxhighlight>

=={{header|Lua}}==

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

if fp == nil then return nil end

return image

end</syntaxhighlight>

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

Now function Bitmap has double signature. With two numbers make a bitmap,with all pixels white. With one number, expect that it is a file number and read file, and then return the bitmap.

Module Checkit {

Function Bitmap {

</syntaxhighlight>

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

</syntaxhighlight>

=={{header|Nim}}==

import bitmap

import streams

let image = readPPM("output.ppm")

echo image.h, " ", image.w</syntaxhighlight>

=={{header|OCaml}}==

let ic = open_in filename in

let line = input_line ic in

and converting a given color file to grayscale:

let img = read_ppm ~filename:"logo.ppm" in

let img = to_color(to_grayscale ~img) in

sending the result to <tt>stdout</tt> allows to see the result without creating a temporary file sending it through a pipe to the '''display''' utility of ''ImageMagick'':

ocaml script.ml | display -

=={{header|Oz}}==

The read function in module <code>"BitmapIO.oz"</code>:

import

Bitmap

The actual task:

[BitmapIO Grayscale] = {Module.link ['BitmapIO.ozf' 'Grayscale.ozf']}

in

{BitmapIO.write {Grayscale.fromGraymap G} "greyimage.ppm"}</syntaxhighlight>

=={{header|Perl}}==

{{libheader|Imlib2}}

use strict;

exit 0;</syntaxhighlight>

=={{header|Phix}}==

Based on [[Bitmap/Read_a_PPM_file#Euphoria|Euphoria]], requires write_ppm() from [[Bitmap/Write_a_PPM_file#Phix|Write_a_PPM_file]], to_grey from [[Grayscale_image#Phix|Grayscale_image]]<br>

Note that demo\rosetta\Bitmap_read_ppm.exw is just the last 3 lines with the include ppm.e since that contains the read_ppm() (abeit with a few more options and other tweaks) also used by several other examples, and covers the above requirements. Results may be verified with demo\rosetta\viewppm.exw

function read_ppm(string filename)

img = to_grey(img)

write_ppm("LenaGray.ppm",img)</syntaxhighlight>

=={{header|PicoLisp}}==

(in File

(unless (and `(hex "5036") (rd 2)) # P6

Y ) ) ) ) ) )</syntaxhighlight>

Read a color image "img.ppm", convert and write to "img.pgm":

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

/* BITMAP FILE: read in a file in PPM format, P6 (binary). 14/5/2010 */

test: procedure options (main);

end is_digit;

end test;</syntaxhighlight>

=={{header|PureBasic}}==

r.c

g.c

To complete the task, the following code should be added to the above fragment and to the PureBasic solutions for [[Grayscale_image#PureBasic|Grayscale image]] and [[Bitmap/Write_a_PPM_file#PureBasic|Write a PPM file]]

file = OpenFileRequester("Select source image file", "", "PPM image (*.ppm)|*.ppm", 0)

If file And LCase(GetExtensionPart(file)) = "ppm"

SaveImageAsPPM(image, file2, 1)

EndIf</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)

'''</syntaxhighlight>

=={{header|Racket}}==

#lang racket

(require racket/draw)

bm))

</syntaxhighlight>

=={{header|Raku}}==

(formerly Perl 6)

Uses pieces from [[Bitmap#Raku| Bitmap]], [[Bitmap/Write_a_PPM_file#Raku| Write a PPM file]] and [[Grayscale_image#Raku| Grayscale image]] tasks. Included here to make a complete, runnable program.

class Bitmap {

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

See [https://github.com/thundergnat/rc/blob/master/img/camelia.png camelia], and [https://github.com/thundergnat/rc/blob/master/img/camelia-gs.png camelia-gs] images. (converted to .png as .ppm format is not widely supported).

=={{header|REXX}}==

The input file &nbsp; '''Lenna50.ppm''' &nbsp; is a '''PPM''' format of

This REXX program handles alternative delimiters as well as comments within the PPM header.

parse arg iFN oFN /*obtain optional argument from the CL.*/

if iFN=='' | iFN=="," then iFN= 'Lenna50' /*Not specified? Then use the default.*/

File greyscale.ppm was created.

</pre>

=={{header|Ruby}}==

Extending [[Basic_bitmap_storage#Ruby]]

# 'open' is a class method

def self.open(filename)

# then, convert to grayscale

Pixmap.open('testcross.ppm').to_grayscale!.save('testgray.ppm')</syntaxhighlight>

=={{header|Rust}}==

parser.rs:

use super::{Color, ImageFormat};

}

</syntaxhighlight>

=={{header|Scala}}==

Uses the [[Basic_bitmap_storage#Scala|Basic Bitmap Storage]] and [[Grayscale_image#Scala|Grayscale Bitmap]] classes.

See also Task [[Write_ppm_file#Scala|Write a PPM File]] for save code.

import scala.swing._

import java.io._

Usage:

def main(args: Array[String]): Unit = {

val img=Pixmap.load("image.ppm").get

}

}</syntaxhighlight>

=={{header|Seed7}}==

include "draw.s7i";

include "color.s7i";

end if;

end func;</syntaxhighlight>

=={{header|Tcl}}==

{{libheader|Tk}}

The actual PPM reader is built into the photo image engine:

proc readPPM {image file} {

}</syntaxhighlight>

Thus, to read a PPM, convert it to grayscale, and write it back out again becomes this (which requires Tcl 8.6 for <code>try</code>/<code>finally</code>); the PPM reader and writer are inlined because they are trivial at the script level:

proc grayscaleFile {filename {newFilename ""}} {

However, the Tk library also has built-in the ability to convert code to grayscale directly during the saving of an image to a file, leading to this minimal solution:

proc grayscaleFile {filename {newFilename ""}} {

}

}</syntaxhighlight>

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

{{works with|ksh93}}

Add the following functions to the <tt>RGBColor_t</tt> type

_.r=$1

_.g=$2

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

RGBColor_t c

for ((y=0; y<_.height; y++)); do

Now we can:

c.read "$HOME/tmp/bitmap.ppm"

c.to_s

c.to_s

c.write "$HOME/tmp/bitmap_g.ppm"</syntaxhighlight>

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

// @10 = filename

// On return:

Example of usage. In addition to LOAD_PPM routine above, you need routine RGB_TO_GRAYSCALE from [[Grayscale image]] and routine SAVE_PPM from [[Write ppm file]].

Reg_Set(10, "|(USER_MACRO)\example.ppm")

Call("LOAD_PPM")

Buf_Switch(#20) Buf_Quit(OK)

return</syntaxhighlight>

=={{header|Wren}}==

{{libheader|DOME}}

This assumes that [https://rosettacode.org/wiki/File:Lenna100.jpg Lenna100.jpg], a 512 x 512 color image of the eponymous lady, has already been converted to Lenna100.ppm using a variation of the 'Write a PPM file' task.

import "dome" for Window, Process

import "io" for FileSystem

var Game = Bitmap.new("Lenna100.ppm", "Lenna100_gs.jpg", 1048, 512)</syntaxhighlight>

=={{header|XPL0}}==

The simplicity of redirecting an input file on the command line doesn't

files larger than 1280x1024 are clipped to the screen dimensions.

func OpenInFile; \Open for input the file typed on command line

SetVid(3); \restore normal text display

]</syntaxhighlight>

=={{header|Yabasic}}==

local ff, x, y, t$, dcol$, wid, hei

return true

end sub</syntaxhighlight>

=={{header|zkl}}==

{{trans|FBSL}}

I used a slightly different image from what is shown, but the results are the same.

[[File:FBSLLena.png|right]]

image:=File("lena.ppm","rb").read();

start:=image.find("\n255\n")+5; // Get sizeof PPM header

File("lenaGrey.ppm","wb").write(image);</syntaxhighlight>

{{omit from|AWK}}

{{omit from|Lotus 123 Macro Scripting}}