Grayscale image: Difference between revisions

 

Many image processing algorithms are defined for [[wp:Grayscale|grayscale]] (or else monochromatic) images.

When using floating-point arithmetic make sure that rounding errors would not cause run-time problems or else distorted results when calculated luminance is stored as an unsigned integer.

<br><br>

 

=={{header|Ada}}==

Conversion to a grayscale image:

type Extended_Luminance is range 0..10_000_000;

Result : Grayscale_Image (Picture'Range (1), Picture'Range (2));

end loop;

return Result;

Conversion to a color image:

Result : Image (Picture'Range (1), Picture'Range (2));

begin

end loop;

return Result;

 

=={{header|BASIC256}}==

[[Image:BASIC256_greyscale_Mona_Lisa.jpg|right]]

[[Image:BASIC256_greysacle_Grey_Mona_lisa.jpg|right]]

h = 188

name$ = "Mona_Lisa.jpg"

next x

 

{{omit from|Batch File}}

 

[[Image:original_bbc.jpg|right]]

[[Image:greyscale_bbc.jpg|right]]

Height% = 200

col% = TINT(x%*2,y%*2)

SWAP ?^col%,?(^col%+2)

 

=={{header|C}}==

Definition/interface for a grayscale image.

 

typedef luminance pixel1[1];

typedef struct {

grayimage alloc_grayimg(unsigned int, unsigned int);

grayimage tograyscale(image);

 

The same as <tt>alloc_img</tt>, but for grayscale images.

 

{

grayimage img;

img->height = height;

return img;

 

Convert from ''color'' image to ''grayscale'' image.

 

{

unsigned int x, y;

}

return timg;

 

And back from a ''grayscale'' image to a ''color'' image.

 

{

unsigned int x, y;

}

return timg;

 

'''Notes'''

* <tt>tocolor</tt> and <tt>tograyscale</tt> do not free the previous image, so it must be freed normally calling <tt>free_img</tt>. With a cast we can use the same function also for grayscale images, or we can define something like

 

 

* ''Luminance'' is rounded. Since the C implementation is based on unsigned char (256 possible values per components), L can be at most 255.0 and rounding gives 255, as we expect. Changing the color_component type would only change 256, 255.0 and 255 values here written in something else, the code would work the same.

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

To convert TO grayscale:

Bitmap tImage = new Bitmap("spectrum.bmp");

 

// Save

tImage.Save("spectrum2.bmp");

 

=={{header|Clojure|Clojure}}==

(import '[java.io File]

'[javax.imageio ImageIO]

"test-gray-cloj.png"))

 

 

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

 

Use the function rgb-to-gray-image to convert a rgb-image as loaded by the function defined [[Bitmap/Read a PPM file#Common Lisp]]. The package identifier assumes that you have the package as defined in [[Basic bitmap storage#Common Lisp]]. With the function grayscale-image-to-pgm-file it is possible to write out the gray image as pgm file which can then be further processed.

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

 

(export 'grayscale-image-to-pgm-file)

 

 

=={{header|Crystal}}==

{{trans|Ruby}}

Extending [[Basic_bitmap_storage#Crystal]]

def to_grayscale

luminosity = (0.2126*@red + 0.7152*@green + 0.0722*@blue).to_i

gray

end

 

=={{header|D}}==

This example uses the bitmap module defined in the [[Bitmap]] Task page.

 

 

import core.stdc.stdio, std.array, std.algorithm, std.string, std.ascii;

img2.rgb2grayImage.savePGM("quantum_frog_grey.pgm");

}

 

=={{header|Erlang}}==

The code below extends the erlang module on [[Bitmap]] task. This module supports RGB and grayscale modes. RGB colors are specified as {rgb, R, G, B} and saved as bytes into an array. Grayscale colors are likewise specified as {gray, L} where L is luminance.

 

 

-export([new/2, fill/2, set_pixel/3, get_pixel/2, convert/2]).

convert(#bitmap{mode=Mode}=Bitmap, Mode) ->

Bitmap.

 

=={{header|Euler Math Toolbox}}==

 

>A=loadrgb("mona.jpg");

>insrgb(A);

>insrgb(grayscale(A));

>insrgb(A|grayscale(A));

 

=={{header|Euphoria}}==

sequence color

for i = 1 to length(image) do

end for

return image

 

=={{header|FBSL}}==

24-bpp BMP-format P.O.T.-size image solution:

[[Image:FBSLLena.png|right]]

DIM head, tail, r, g, b, l, ptr, blobsize = 54 ' sizeof BMP file headers

 

NEXT

 

 

=={{header|Forth}}==

 

\ bdim, bwidth, bdata all work with graymaps

over i j rot b!

loop

 

=={{header|Fortran}}==

First let's define a new type; the <tt>sc</tt> stands for Single Channel, which can be luminance (as it is here).

 

integer, dimension(:,:), pointer :: channel

integer :: width, height

 

In order to allow proper overloading, the following subroutines of the [[Basic bitmap storage#Fortran|storage]] should be renamed appending the <tt>_rgb</tt> suffix: valid_image, inside_image, alloc_img, free_img, fill_img, get_pixel, put_pixel, init_img. The ''single channel'' version would be named with the <tt>_sc</tt> suffix, then we should define the proper interfaces to use the already written code as before. Here there are only the interfaces and subroutines needed for the task.

 

module procedure alloc_img_rgb, alloc_img_sc

end interface

interface free_img

module procedure free_img_rgb, free_img_sc

 

Now we can define useful interfaces and subroutines more task-related:

 

module procedure rgbtosc, sctorgb

 

type(scimage) :: img

integer, intent(in) :: w, h

end if

 

 

'''Usage example''' (fragment) which can be used to convert from ''rgb'' image to ''grayscale'' image and back (since we only can output the ''rgb'' kind):

 

type(rgbimage) :: animage

! ... here we "load" or create animage

gray = animage

animage = gray

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

 

import (

}

return b

For demonstration program see task [[Bitmap/Read a PPM file]].

 

=={{header|Haskell}}==

 

import Bitmap

 

toGrayImage :: Color c => Image s c -> ST s (Image s Gray)

 

A <tt>Gray</tt> image can be converted to an <tt>RGB</tt> image with <tt>Bitmap.RGB.toRGBImage</tt>, defined [[Basic bitmap storage|here]].

Grayscale image is stored as two-dimensional array of luminance values. Allowed luminance scale is the same as for the color bitmap; the functions below are neutral to scale.

 

NB. L = 0.2126*R + 0.7152*G + 0.0722*B

toGray=: [: <. +/ .*"1&0.2126 0.7152 0.0722

 

NB. converts grayscale image to the color image, with all channels equal

 

Example:

 

 

=={{header|Java}}==

for(int i=0; i<image.getWidth(); i++){

for(int j=0; j<image.getHeight(); j++){

}

}

 

=={{header|JavaScript}}==

HTML 5

Demonstration: https://repl.it/repls/NiceFaroffRockrat

function toGray(img) {

let cnv = document.getElementById("canvas");

return cnv.toDataURL();

}

 

=={{header|Julia}}==

'''Adhering to the Task Description'''

using Color, Images, FixedPointNumbers

 

imc = gray2rgb(imb)

imwrite(imc, "grayscale_image_rc.png")

Rounding errors are unlikely to be an issue for <code>rgb2gray</code>. The calculation of <code>g</code> promotes it to the literal float type (typically <code>Float64</code>).

 

'''A More Idiomatic Approach'''

using Color, Images, FixedPointNumbers

 

imb = convert(Image{Gray{Ufixed8}}, ima)

imwrite(imb, "grayscale_image_julia.png")

 

{{output}}

 

As it's not possible to recover the original colored image (because different combinations of RGB values could have produced the same luminance), I have not bothered with the reverse operation.

 

import java.io.File

val grayFile = File("bbc_gray.jpg")

ImageIO.write(image, "jpg", grayFile)

 

{{out}}

 

=={{header|Liberty BASIC}}==

nomainwin

WindowWidth = 400

wait

[q] unloadbmp "clr":close #1:end

 

=={{header|Lingo}}==

res = image(img.width, img.height, 8)

res.paletteRef = #grayScale

end repeat

return res

 

=={{header|Lua}}==

 

local size_x, size_y = #bitmap, #bitmap[1]

local gray_im = {}

return bitmap

 

=={{header|Maple}}==

Maple has builtin command for conversion from RGB to Grayscale image: ImageTools:-ToGrayScale, which uses gray = 0.30 red + 0.59 green + 0.11 blue, the following implementation uses the CIE formula. Note that the conversion back from GrayScale to RGB uses Maple's builtin command: ImageTools:-ToRGB.

#conversion forward

dimensions:=[upperbound(img)];

ToRGB(x);

#display the result

 

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

Mathematica has a built-in grayscale conversion function called "ColorConvert". This example does not use it since it appears the luminance calculation is different from the CIE spec. Grayscale to RGB "conversion" just changes the single channel grayscale image to a triple channel image.

 

=={{header|MATLAB}}==

Built in colour to grayscale converter uses the following forumula:

0.2989*R + 0.5870*G + 0.1140*B

 

=={{header|OCaml}}==

 

Conversion to a grayscale image:

let width = Bigarray.Array2.dim1 r_channel

and height = Bigarray.Array2.dim2 r_channel in

done;

done;

 

Conversion to a color image:

let width = Bigarray.Array2.dim1 gray_channel

and height = Bigarray.Array2.dim2 gray_channel in

r_channel,

g_channel,

 

and functions to get/set a pixel:

 

(fun x y -> gray_channel.{x,y})

 

let gray_put_pixel_unsafe (gray_channel) v =

 

=={{header|Octave}}==

'''Use package''': image

 

 

Differently from [[Grayscale image#MATLAB|MATLAB]], the grayscale is computed as mean of the three RGB values. Changing this non-optimal behaviour is a matter of fixing three lines in the <tt>rgb2gray.m</tt> file; since it's a GPL-ed code, here it is a semplified version (error checking, usage help, argument checking removed)

 

switch(class(rgb))

case "double"

function lum = luminance(rgb)

lum = 0.2126*rgb(:,:,1) + 0.7152*rgb(:,:,2) + 0.0722*rgb(:,:,3);

 

Original code of the <tt>rgb2gray.m</tt> in the image package version 1.0.8 is by Kai Habel (under the GNU General Public License)

We define a "graymap" as a two-dimensional array of floats. In module <code>"Grayscale.oz"</code>, we implement conversion functions from and to bitmaps:

 

import

Array2D

color(L L L)

end

 

=={{header|Perl}}==

Since we are using Imlib2, this one '''does''' '''not''' implement really a gray-scale (single channel) storage; it only ''converts'' an RGB image to an RGB image with the same three colour components for each pixel (which result in a gray-scale-like image)

 

 

use strict;

$gscale->save("Lennagray.jpg");

 

 

=={{header|Phix}}==

{{Trans|Euphoria}}

end for

end for

return image

end function

sequence img = read_ppm("Lena.ppm")

 

=={{header|PHP}}==

Uses the [[Write ppm file#PHP|Bitmap class]] defined for writing a PPM file

public function toGrayscale(){

for ($i = 0; $i < $this->h; $i++){

$b->setPixel(0, 13, array(0,0,255));

$b->toGrayscale();

 

=={{header|PicoLisp}}==

(de ppm->pgm (Ppm)

(mapcar

'((G) (list G G G))

Y ) )

(de pgmWrite (Pgm File)

(out File

 

# Convert to color image and write to .ppm file

 

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

do j = 1 to hbound(image,1);

do i = 0 to hbound(image,2);

end;

end;

 

=={{header|PureBasic}}==

Protected w, h, x, y, r, g, b, gray, color

Next

StopDrawing()

 

=={{header|Python}}==

 

Extending the example given [[Basic_bitmap_storage#Alternative_version|here]]

import io

ppmfileout = io.StringIO('')

254 254 254 31 31 31 254 254 254 254 254 254

 

 

=={{header|R}}==

{{libheader|pixmap}}

setAs("pixmapGrey", "pixmapRGB",

function(from, to){

 

# Convert back to "colour"

 

=={{header|Racket}}==

I gave up on uploading to Rosetta Code.

 

#lang racket

(require racket/draw)

(color->gray rosetta)

(gray->color (color->gray rosetta))

 

=={{header|Raku}}==

 

This script expects to be fed a P6 .ppm file name at the command line. It will convert it to grey scale and save it as a binary portable grey map (P5 .pgm) file.

 

my $in = open($filename, :r, :enc<iso-8859-1>) or die $in;

for $in.lines.ords -> $r, $g, $b {

my $gs = $r * 0.2126 + $g * 0.7152 + $b * 0.0722;

}

 

$in.close;

$out.close;

Using the .ppm file from the [[Bitmap/Write a PPM file#Raku|Write a PPM file]] task:

 

Note: &nbsp; REXX uses decimal (characters) instead of binary for storing numbers, &nbsp; so there is no rounding &nbsp; (using

<br>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;characters to store numbers is almost the same as using decimal floating point).

blue= '00 00 ff'x /*define the blue color (hexadecimal).*/

@.= blue /*set the entire image to blue color.*/

end /*row*/ /* [↑] D2C convert decimal ───► char*/

end /*col*/ /* [↑] x%1 is the same as TRUNC(x) */

 

=={{header|Ruby}}==

Extending [[Basic_bitmap_storage#Ruby]]

def to_grayscale

luminosity = Integer(0.2126*@red + 0.7152*@green + 0.0722*@blue)

gray

end

 

=={{header|Scala}}==

Uses the [[Basic_bitmap_storage#Scala|Scala Basic Bitmap Storage]] class.

def luminosity(c:Color)=(0.2126*c.getRed + 0.7152*c.getGreen + 0.0722*c.getBlue+0.5).toInt

 

image

}

 

=={{header|Sidef}}==

{{trans|Perl}}

 

func tograyscale(img) {

var gscale = tograyscale(image)

gscale.set_quality(80)

 

=={{header|Tcl}}==

<!-- L = 0.2126·R + 0.7152·G + 0.0722·B -->

{{libheader|Tk}}

 

proc grayscale image {

}

}

Photo images are always 8-bits-per-channel RGBA.

 

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

Conversion to a grayscale image.<br>

// #10 = buffer that contains image data

// On return:

Buf_Switch(#10)

}

 

Conversion to a color image.<br>

// #20 = buffer that contains image data

// On return:

Buf_Switch(#20)

}

 

=={{header|Visual Basic .NET}}==

Convert a Bitmap to Grayscale.

 

Imports System.Drawing.Imaging

 

Map.UnlockBits(oBMPData)

 

 

=={{header|Yabasic}}==

{{trans|BASIC256}}

"image" is a library created by Hermang Mansilla for import and show .BMP files. http://www.oocities.org/sunsetstrip/palms/1624/yabasic/libs/IMAGE.TXT

 

open window 600,600

dot x+300,y+300

next y

 

=={{header|zkl}}==

Uses the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl

{{trans|BASIC256}}

foreach x,y in (img.w,img.h){

r,g,b:=img[x,y].toBigEndian(3);

img[x,y]=((lum*256) + lum)*256 + lum;

}

toGrayScale(img);

{{out}}

http://www.zenkinetic.com/Images/RosettaCode/lenaGray.jpg