Bitmap/PPM conversion through a pipe: Difference between revisions

Using the data storage type defined [[Basic_bitmap_storage|on this page]] for raster images, delegate writing a JPEG file through a '''pipe''' using the <tt>output_ppm</tt> function defined [[Write_ppm_file|on this other page]].

 

 

=={{header|C}}==

This one uses the ImageMagick <tt>convert</tt> tool.

 

 

void print_jpg(image img, int qual)

{

pclose(pipe);

}

 

The code that writes to the pipe is the same of [[Write_ppm_file|output_ppm]] of course. A complete example is

 

 

int main()

print_jpg(img, 75);

free_img(img);

 

In order to make it working, you must link it with the raster image functions given by the codes [[Bresenham's_line_algorithm#C|here]] and [[Basic_bitmap_storage#C|here]]

{{works with|Go weekly.2011-12-14}} (Go 1 should be close)

Using cjpeg:

 

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

fmt.Println(err)

}

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

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

=={{header|Kotlin}}==

{{works with|Ubuntu 16.04}}

In order to provide a complete runnable example, we repeat bits of code from other relevant tasks and add code which pipes .ppm data to ImageMagick's 'convert' tool which then writes the corresponding .jpg file to disk.

 

import java.awt.Color

}

}

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

The Windows command line does not like quotes in the middle of text, so strings have been turned into character codes.

"wolfram","-noinit","-noprompt","-run",

"Export[FromCharacterCode["~~ToString[ToCharacterCode[out]]~~"],ImportString[StringRiffle[Table[InputString[],{4}],FromCharacterCode[10]],FromCharacterCode[{80,80,77}]]]"

WriteLine[process,image];

WriteLine[process,"Quit[]"];

=={{header|Nim}}==

We use "convert" command from ImageMagick and "pnmtojpeg" command from Netpbm. The first command allows to specify the output file name, the second writes to stdout and, so, we have to use a redirection. Thus, the way to launch the process is slightly different.

 

import ppm_write

import osproc

stream = p.inputStream()

image.writePPM(stream)

 

=={{Header|OCaml}}==

 

let cmd = Printf.sprintf "cjpeg -quality %d" quality in

(*

done

with End_of_file -> ()

 

 

 

 

=={{header|PicoLisp}}==

(setq *Ppm (make (do 90 (link (need 120)))))

 

 

# Write to "img.jpg" through a pipe

=={{header|Python}}==

"""

Adapted from https://stackoverflow.com/questions/26937143/ppm-to-jpeg-jpg-conversion-for-python-3-4-1

im = Image.open("boxes_1.ppm")

im.save("boxes_1.jpg")

Does not need to pipe through a conversion utility

because the Pillow module does the conversion.

=={{header|Racket}}==

(define (ppm->jpeg bitmap [jpg-file "output"] [quality 75])

(define command (format "convert ppm:- -quality ~a jpg:~a.jpg" quality jpg-file))

(close-output-port out))

 

=={{header|Raku}}==

(formerly Perl 6)

# https://rosettacode.org/wiki/Bitmap/Write_a_PPM_file#Raku

 

my $proc = run '/usr/bin/convert','-','output_piped.jpg', :in;

$proc.in.write: $b.P6;

{{out}}

<pre>file output_piped.jpg

output_piped.jpg: JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, baseline, precision 8, 125x125, frames 3</pre>

=={{header|Ruby}}==

Extends [[Write ppm file#Ruby]]. Uses the ImageMagick <code>convert</code> tool.

Additionally, for debugging, allow writing in pixmap P3 (ascii) format.

 

PIXMAP_FORMATS = ["P3", "P6"] # implemented output formats

PIXMAP_BINARY_FORMATS = ["P6"] # implemented output formats which are binary

 

image = Pixmap.open('file.ppm')

=={{header|Standard ML}}==

This function uses convert, and retrieves its output

val useOSConvert = fn ppm =>

let

)

end;

call and return value

useOSConvert "P3 3 2 255 255 0 0 0 255 0 0 0 255 255 255 0 255 255 255 0 0 0" ;

val it =

fromList[0wxFF, 0wxD8, 0wxFF, 0wxE0, 0wx0, 0wx10, 0wx4A, 0wx46, 0wx49,

0wx46, ...]: BinIO.vector

This is the fire-and-forget version.

val demo = fn () =>

let

 

end ;

output, after compilation to 'demo'

shell$ demo

shell$ file /tmp/out.jpeg

/tmp/out.jpeg: JPEG image data, JFIF standard 1.01, aspect ratio, density 1x1, segment length 16, baseline, precision 8, 3x2, frames 3

=={{header|Tcl}}==

Referring to [[Write ppm file#Tcl]] and [[Basic bitmap storage#Tcl]]

 

{{libheader|Tk}}

 

proc output_jpeg {image filename {quality 75}} {

puts -nonewline $f [$image data -format ppm]

close $f

However, it is more normal to do this directly with the {{libheader|TkImg}} which is bundled with many Tcl distributions.

package require img::jpeg

 

}

set img [image create photo -filename filename.ppm]

 

=={{header|zkl}}==

 

Using the convert utility by ImageMagick:

p:=System.popen(0'|convert ppm:- jpg:"fractal.jpg"|,"w");

{{omit from|GUISS}}

{{omit from|PARI/GP}}

{{omit from|ZX Spectrum Basic|Does not have pipelining}}