Bitmap/Histogram: Difference between revisions

* Replace each pixel of luminance lesser than the median to black, and others to white.

Use [[read ppm file | read]]/[[write ppm file]], and [[grayscale image]] solutions.

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

In the following solution the input file [https://gitlab.com/amarok8bit/action-rosetta-code/-/blob/master/source/lena30g.PPM lena30g.PPM] is loaded from H6 drive. Altirra emulator automatically converts CR/LF character from ASCII into 155 character in ATASCII charset used by Atari 8-bit computer when one from H6-H10 hard drive under DOS 2.5 is used.

{{libheader|Action! Bitmap tools}}

 

DEFINE HISTSIZE="256"

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Bitmap_Histogram.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

Histogram of an image:

type Histogram is array (Luminance) of Pixel_Count;

end Get_Histogram;</syntaxhighlight>

Median of a histogram:

From : Luminance := Luminance'First;

To : Luminance := Luminance'Last;

end Median;</syntaxhighlight>

Conversion of an image to black and white art:

begin

Open (F1, In_File, "city.ppm");

end;

Close (F2);</syntaxhighlight>

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

{{works with|BBC BASIC for Windows}}

[[Image:greyscale_bbc.jpg|right]]

[[Image:histogram_bbc.gif|right]]

Sort% = FN_sortinit(0,0)

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

= col%</syntaxhighlight>

=={{header|C}}==

 

typedef histogram_t *histogram;

 

luminance histogram_median(histogram h);</syntaxhighlight>

 

{

histogram t;

{{trans|Ada}}

 

{

luminance From, To;

An example of usage is the following code.

 

#include <stdlib.h>

#include "imglib.h"

 

Which reads from the file specified from the command line and outputs to the standard out the PPM B/W version of the input image. The input image can be of any format handled by ImageMagick (see [[Read image file through a pipe]])

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

{{libheader|opticl}}

(:use #:cl

#:opticl))

(bw-image (gray->black&white-image (color->gray-image image))))

(write-pbm-file "lenna-bw.pbm" bw-image)))</syntaxhighlight>

=={{header|D}}==

{{trans|Ada}}

It uses the grayscale_image from the Grayscale image Task. The loaded frog image is from the Color quantization Task.

 

Color findSingleChannelMedian(Color)(in Image!Color img)

.savePGM("quantum_frog_bin.pgm");

}</syntaxhighlight>

=={{header|FBSL}}==

FBSL volatiles and function call concatenation used heavily for brevity.

'''24-bpp P.O.T.-size BMP solution:'''

[[File:FBSLHistogram.PNG|right]]

 

DIM colored = ".\LenaClr.bmp", grayscale = ".\LenaGry.bmp", blackwhite = ".\LenaBnw.bmp"

FILEPUT(FILEOPEN(blackwhite, BINARY_NEW), FILEGET): FILECLOSE(FILEOPEN) ' save b/w image

END SUB</syntaxhighlight>

=={{header|Forth}}==

over 256 cells erase

dup bdim * over bdata + swap bdata

do 1 over i c@ cells + +! loop drop ;</syntaxhighlight>

 

=={{header|Fortran}}==

'''Note''': ''luminance'' range is hard-encoded and is from 0 to 255. This could be enhanced.

 

use RCImageBasic

implicit none

Example:

 

use RCImageBasic

use RCImageIO

 

end program BasicImageTests</syntaxhighlight>

=={{header|Go}}==

Histogram and Threshold functions are be added to the Grmap type for this task:

 

import "math"

}</syntaxhighlight>

Demonstration program computes the median:

 

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

}

}</syntaxhighlight>

=={{header|Haskell}}==

First, an implementation of a black-and-white instance of <tt>Color</tt>. For simplicty, we use ASCII PBM for output instead of the raw format.

 

import Bitmap

 

Every instance of <tt>Color</tt> has a <tt>luminance</tt> method, so we don't need to convert an image to <tt>Gray</tt> to calculate its histogram.

import Bitmap.RGB

import Bitmap.BW

then (n + 1, left + l, right, ls, rL)

else (n, left, right + r, lL, rs)</syntaxhighlight>

=={{header|J}}==

'''Solution:'''

 

Using <code>toGray</code> from [[Grayscale image#J|Grayscale image]].

medianHist=: {."1 {~ [: (+/\ I. -:@(+/)) {:"1

toBW=: 255 * medianHist@getImgHist < toGray</syntaxhighlight>

Use [http://rosettacode.org/mw/images/b/b6/Lenna100.jpg Lenna100.jpg] for testing (read using the [[j:Addons/media/platimg|media/platimg]] addon and convert to ppm file).

 

'Lenna100.ppm' writeppm~ 256#.inv readimg 'Lenna100.jpg'

786447</syntaxhighlight>

 

Read ppm file, convert to black and white and write to a new ppm file using <code>writeppm</code>, <code>readppm</code> and <code>toColor</code> from the [[read ppm file#J | read]]/[[write ppm file#J|write ppm file]], and [[grayscale image#J|grayscale image]] solutions.

786447</syntaxhighlight>

=={{header|Java}}==

import java.io.File;

import java.io.IOException;

}

}</syntaxhighlight>

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

ima = load("data/lenna50.jpg")

imb[imb .> medcol] = Gray(1.0)

save("data/lennaGray.jpg", imb)</syntaxhighlight>

=={{header|Kotlin}}==

Uses the image from the [[Percentage difference between images]] task as an example.

 

import java.io.File

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

}</syntaxhighlight>

=={{header|Lua}}==

This solution uses functions defined at:

[[Basic bitmap storage#Lua]],

[[Grayscale image#Lua]].

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

bitmap = ConvertToColorImage( gray_im )

Write_PPM( "outputimage.ppm", bitmap )</syntaxhighlight>

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

=={{header|Nim}}==

import grayscale_image

 

# Save image as a PPM file.

image.writePPM("house_bw.ppm")</syntaxhighlight>

=={{header|OCaml}}==

{{Trans|C}}

 

 

let get_histogram ~img:gray_channel =

;;</syntaxhighlight>

 

 

let from = 0 and to_ = 255 in

 

main:

let img = read_ppm ~filename:"/tmp/foo.ppm" in

 

output_ppm ~oc:stdout ~img:res;

;;</syntaxhighlight>

=={{header|Octave}}==

'''Using package''' [http://octave.sourceforge.net/image/index.html Image]

if ( isgray(imago) )

for j = 0:255

ibw( img <= m ) = 0;

jpgwrite("lennamed.jpg", ibw, 100);</syntaxhighlight>

=={{header|Phix}}==

Requires read_ppm() from [[Bitmap/Read_a_PPM_file#Phix|Read_a_PPM_file]], write_ppm() from [[Bitmap/Write_a_PPM_file#Phix|Write_a_PPM_file]]. <br>

Uses demo\rosetta\lena.ppm, included in the distribution, results may be verified with demo\rosetta\viewppm.exw

include ppm.e -- black, white, read_ppm(), write_ppm() (covers above requirements)

 

img = to_bw(img)

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

=={{header|PHP}}==

 

define('src_name', 'input.jpg'); // source image

define('dest_name', 'output.jpg'); // destination image

</i>

</div>

=={{header|PicoLisp}}==

{{trans|Forth}}

(let H (need 256 0)

(for L Pgm

(inc (nth H (inc G))) ) )

H ) )</syntaxhighlight>

=={{header|PureBasic}}==

Also requires PureBasic solutions for [[Bitmap/Read_a_PPM_file#PureBasic|Read a PPM file]], [[Grayscale_image#PureBasic|Grayscale image]], and [[Bitmap/Write_a_PPM_file#PureBasic|Write a PPM file]].

Protected w = ImageWidth(image) - 1

Protected h = ImageHeight(image) - 1

SaveImageAsPPM(image, outputFile, 1)

EndIf</syntaxhighlight>

=={{header|Python}}==

Makes use of the Pillow library (PIL) you can install it using pip. The code is probably not the fastest or the image I used (1960x1960) is just too big.

 

# Open the image

bw_image.show()

bm_image.show()</syntaxhighlight>

=={{header|Racket}}==

(require racket/draw math/statistics racket/require

(filtered-in

 

Sorry guys... I just give up on linking/displaying these images any other way!

=={{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/Lenna.png Lenna], and [https://github.com/thundergnat/rc/blob/master/img/Lenna-bw.png Lenna-bw] images. (converted to .png as .ppm format is not widely supported).

=={{header|Ruby}}==

def histogram

histogram = Hash.new(0)

 

Pixmap.open('file.ppm').save_as_blackandwhite('file_bw.ppm')</syntaxhighlight>

=={{header|Rust}}==

use image::{DynamicImage, GenericImageView, ImageBuffer, Rgba};

 

}

</syntaxhighlight>

=={{header|Scala}}==

See also

* [[Read_ppm_file#Scala|Read a PPM File]] image loading

 

def histogram(bm:RgbBitmap)={

val hist=new Array[Int](255)

 

Usage:

val hist=BitmapOps.histogram(img)

val mid=BitmapOps.histogram_median(hist);

}

}</syntaxhighlight>

=={{header|Tcl}}==

{{libheader|Tk}}

Uses [[read ppm file#Tcl|readPPM]], [[grayscale image#Tcl|grayscale]] and [[write ppm file#Tcl|output_ppm]] from other pages.

package require Tk

 

}

}</syntaxhighlight>

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

The input image is in edit buffer pointed by numeric register #15.

On return, #30 points to buffer containing histogram data.

The histogram data is given as ASCII decimal values, one value per line.

#30 = Buf_Free // #30 = buffer to store histogram data

for (#9=0; #9<256; #9++) {

}

Return</syntaxhighlight>

=={{header|Wren}}==

{{libheader|DOME}}

import "graphics" for Canvas, Color, ImageData

 

class ImageHistogram {

construct new(filename, filename2) {

Window.resize(_image.width, _image.height)

Canvas.resize(_image.width, _image.height)

{{trans|C}}

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

hist:=List.createLong(256,0); // array[256] of zero

image.data.howza(0).pump(Void,'wrap(c){ hist[c]+=1 }); // byte by byte loop

from

}</syntaxhighlight>

median:=histogramMedian(histogram(img));

median.println();

See the BBC Basic entry or:

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

{{omit from|AWK}}

{{omit from|PARI/GP}}