Bitmap/Histogram: Difference between revisions

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"

DO UNTIL CH#$FF OD

CH=$FF

{{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 loop;

return Result;

Median of a histogram:

From : Luminance := Luminance'First;

To : Luminance := Luminance'Last;

end loop;

return From;

Conversion of an image to black and white art:

begin

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

Put_PPM (F2, X);

end;

 

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

[[Image:greyscale_bbc.jpg|right]]

[[Image:histogram_bbc.gif|right]]

Sort% = FN_sortinit(0,0)

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

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

 

=={{header|C}}==

 

typedef histogram_t *histogram;

 

 

histogram get_histogram(grayimage im);

 

{

histogram t;

}

return t;

 

The given <tt>histogram</tt> must be freed with a simple <tt>free(histogram)</tt>.

{{trans|Ada}}

 

{

luminance From, To;

}

return From;

 

An example of usage is the following code.

 

#include <stdlib.h>

#include "imglib.h"

free_img((image)g_img);

free_img(color_img);

 

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

(let* ((image (read-jpeg-file "lenna.jpg"))

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

 

=={{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)

img.binarizeInPlace(img.findSingleChannelMedian())

.savePGM("quantum_frog_bin.pgm");

 

=={{header|FBSL}}==

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

[[File:FBSLHistogram.PNG|right]]

 

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

NEXT

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

 

=={{header|Forth}}==

over 256 cells erase

dup bdim * over bdata + swap bdata

 

=={{header|Fortran}}==

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

 

use RCImageBasic

implicit none

end function histogram_median

 

Example:

 

use RCImageBasic

use RCImageIO

call free_img(gray)

 

 

=={{header|Go}}==

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

 

import "math"

}

}

Demonstration program computes the median:

 

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

fmt.Println(err)

}

 

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

toBWImage' darkestWhite = mapImage $ f . luminance

where f x | x < darkestWhite = black

 

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

if left < right

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

 

=={{header|J}}==

 

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

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

 

'''Example Usage:'''

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'

 

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.

 

=={{header|Java}}==

import java.io.File;

import java.io.IOException;

return median;

}

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

 

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

imb[imb .≤ medcol] = Gray(0.0)

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

 

=={{header|Kotlin}}==

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

 

import java.io.File

val bwFile = File("Lenna_bw.jpg")

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

 

=={{header|Lua}}==

[[Basic bitmap storage#Lua]],

[[Grayscale image#Lua]].

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

 

bitmap = ConvertToColorImage( gray_im )

 

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

 

=={{header|Nim}}==

import grayscale_image

 

 

# Save image as a PPM file.

 

=={{header|OCaml}}==

{{Trans|C}}

 

 

let get_histogram ~img:gray_channel =

done;

(t: histogram)

 

 

let from = 0 and to_ = 255 in

in

aux from to_ left right

 

main:

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

 

 

output_ppm ~oc:stdout ~img:res;

 

=={{header|Octave}}==

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

if ( isgray(imago) )

for j = 0:255

ibw( img > m ) = 255;

ibw( img <= m ) = 0;

 

=={{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)

 

sequence img = read_ppm("Lena.ppm")

img = to_bw(img)

 

=={{header|PHP}}==

 

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

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

echo 'Image not saved! Check permission!';

}

Example: <br>

<div>

=={{header|PicoLisp}}==

{{trans|Forth}}

(let H (need 256 0)

(for L Pgm

(for G L

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

 

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

outputFile = Left(sourceFile, Len(sourceFile) - Len(GetExtensionPart(sourceFile))) + "_bw." + GetExtensionPart(sourceFile)

SaveImageAsPPM(image, outputFile, 1)

 

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

 

=={{header|Racket}}==

(require racket/draw math/statistics racket/require

(filtered-in

(send (bitmap->monochrome 1/4 bm) save-file "histogram-racket-0.25.png" 'png)

(send (bitmap->monochrome 1/2 bm) save-file "histogram-racket-0.50.png" 'png) ; median

 

{{out}}

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

histogram($b);

 

 

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)

end

 

 

=={{header|Rust}}==

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

 

img.save("lena-mono.png").expect("could not save result image");

}

 

=={{header|Scala}}==

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

 

def histogram(bm:RgbBitmap)={

val hist=new Array[Int](255)

image

}

 

Usage:

val hist=BitmapOps.histogram(img)

val mid=BitmapOps.histogram_median(hist);

icon=new ImageIcon(BitmapOps.monochrom(img, mid).image)

}

 

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

 

}

}

 

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

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++) {

Num_Ins(#8, FILL) // store count

}

 

=={{header|Wren}}==

{{libheader|DOME}}

import "graphics" for Canvas, Color, ImageData

 

}

 

 

=={{header|zkl}}==

{{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

median:=histogramMedian(histogram(img));

median.println();

img.data.pump(bw.data.clear(),'wrap(c){ if(c>median) 0xff else 0 });

 

{{out}}<pre>101</pre>

See the BBC Basic entry or: