# How can I extract data points from a black and white image?

Consider the following graph (source):

Is there any way to extract the data points from this image in a semi-automatic way? I have seen, and tried the methods suggested in this question, but they did not work, as most of the approaches there utilize color contrast to extract the data; I couldn't get barChartDigitizer to work, either.

• See this question too, which was also mentioned in the comments on the one you linked to dsp.stackexchange.com/a/1061/581
– rm -rf
Apr 2, 2012 at 15:59
• It is not Mathematica-related, but WebPlotDigitizer is a great web tool to extract published data from graph images.
– F'x
Apr 2, 2012 at 18:13
• can you explain how barChartDigitizer failed? Apr 3, 2012 at 0:06
• ...but in any case I like @kguler's answer: mathematica.stackexchange.com/questions/1524/… though not sure why it would not have worked for this picture?? Apr 3, 2012 at 0:08
• ok just tried it. forgot that it only stores y values. Should be easy to extend to lines. This is actually my code from a couple of years ago that I put on wildebeest.net. I'll update for lines. Apr 3, 2012 at 0:18

Here the contours of a method to do this half-automatic selection you are looking for. It is heavily based on an example on the ImageCorrelate doc page of Waldo fame. First, you interactively select an example of the plot marker you want to look for:

img = Import["http://i.stack.imgur.com/hhPr9.png"];

pt = {ImageDimensions[img]/4, ImageDimensions[img]/2};
LocatorPane[
Dynamic[pt],
Dynamic[
Show[
img,
Graphics[
{
EdgeForm[Black], FaceForm[], Rectangle @@ pt
}
]
]
], Appearance -> Graphics[{Red, AbsolutePointSize[5], Point[{0, 0}]}]
]


Then you use Mathematica v8's image processing tools to find similar structures:

res =
ComponentMeasurements[
MorphologicalComponents[
ColorNegate[
Binarize[
ImageCorrelate[
img,
ImageTrim[img, pt],
NormalizedSquaredEuclideanDistance
], 0.18
]
]
], {"Centroid", "Area"}, #2 > 1 & (*use only the larger hits*)
];


The coordinates are now in res. I'll show them below. Many are correct, sometimes you get some spurious hits and misses. It depends on the Binarize threshold value and the "Area" size chosen in ComponentMeasurements third argument.

Show[img, Graphics[{Green, Circle[#, 5] & /@ res[[All, 2, 1]]}]]


EDIT: Here a more complete application. It is not robust as it is (no error handling at all), but nevertheless already quite useful.

The function getMarkers is called with an image as argument and the name of a variable in which the final markers are returned:

You get the app with tabs that represent processing stages:

In the first tab you define the axes by dragging the colored dots to the locations on the x and y axis with the highest known value and to the origin of the plot. Here, you also enter the values for the bottom left and top right corners of the rectangle that they define:

In the next tab you then indicate the marker you want to have detected:

The detection results are presented in the next tab and you can drag a slider to increase or decrease the number of results:

You can manually adjust the detected markers in the next tab. Markers can be dragged, removed (alt-click an existing marker) and added (alt-click on an empty spot). Actually, this is so easy to do that I would be tempted to say that I could do without the marker-detection phase.

The end result can be seen in the Results tab. If something is wrong you can go back to an earlier tab: .

The data plotted in the Results tab is also copied in the variable passed to the function, test in this example.

test

(*
==> {{400.5159959, 0.007353847123}, {450.3095975,
0.005511544915}, {499.8452012, 0.004129136525}, {550.9287926,
0.002664992936}, {600.4643963, 0.001702431875}, {653.869969,
0.000764540446}, {685.6037152, 0.0002398789942}, {764.7123323,
0.0002481309886}, {801.7027864, 0.0001989932135}}
*)


The code:

findMarkers[img_, pt_, thres_, minArea_] :=
ComponentMeasurements[
MorphologicalComponents[
ColorNegate[
Binarize[
ImageCorrelate[
img,
ImageTrim[img, pt],
NormalizedSquaredEuclideanDistance
], thres
]
]
], {"Centroid", "Area"}, #2 > minArea &
][[All, 2, 1]];

SetAttributes[getMarkers, HoldRest];
getMarkers[img_, resMarkers_] :=
DynamicModule[
{
pt = {ImageDimensions[img]/4, ImageDimensions[img]/2},
axisDefinePane, defineMarkerPane, findMarkerPane, editMarkersPane,
finalResultPane, xAxisBegin, xAxisEnd, yAxisBegin, yAxisEnd,
myMarkers, myTransform,
xoy = {{1/2, 1/8} ImageDimensions[img],
{1/8, 1/8} ImageDimensions[img],
{1/8, 1/2} ImageDimensions[img]}
},

axisDefinePane =
Grid[{{
LocatorPane[
Dynamic[xoy],
Dynamic[
Show[
img,
Graphics[{Line[xoy]}]
]
],
Appearance -> {Graphics[{Red, AbsolutePointSize[5],
Point[{0, 0}]}],
Graphics[{Green, AbsolutePointSize[5], Point[{0, 0}]}],
Graphics[{Blue, AbsolutePointSize[5], Point[{0, 0}]}]}
]},
{Row[{"x(1): ",
InputField[Dynamic[xAxisBegin], Number, FieldSize -> Tiny],
" x(2): ",
InputField[Dynamic[xAxisEnd], Number, FieldSize -> Tiny]}]},
{Row[{"y(1): ",
InputField[Dynamic[yAxisBegin], Number, FieldSize -> Tiny],
" y(2): ",
InputField[Dynamic[yAxisEnd], Number, FieldSize -> Tiny]}]}
}
];

defineMarkerPane =
LocatorPane[
Dynamic[pt],
Dynamic[
Show[
img,
Graphics[
{
EdgeForm[Black], FaceForm[], Rectangle @@ pt
}
]
]
],
Appearance -> Graphics[{Red, AbsolutePointSize[5], Point[{0, 0}]}]
];

findMarkerPane =
Manipulate[
Show[
img,
Graphics[{Red,Circle[#, 5] & /@ (myMarkers = findMarkers[img, pt, t, 1.05])}]
],
{{t, 0.2, "Threshold"}, 0, 1},
TrackedSymbols -> {t},
ControlPlacement -> Bottom
];

editMarkersPane =
LocatorPane[Dynamic[ myMarkers], img,
Appearance -> Graphics[{Red, Circle[{0, 0}, 1]}, ImageSize -> 10],
LocatorAutoCreate -> True
];

finalResultPane =
Dynamic[myTransform =
FindGeometricTransform[
{{xAxisEnd, yAxisBegin}, {xAxisBegin, yAxisBegin},
{xAxisBegin, yAxisEnd}
}, xoy
][[2]] // Quiet;
ListLinePlot[resMarkers = myTransform /@ Sort[myMarkers],
Frame -> True, Mesh -> All],
TrackedSymbols -> {myMarkers, xoy, xAxisEnd, yAxisBegin,
xAxisBegin, yAxisBegin, xAxisBegin, yAxisEnd}];

TabView[
{
"Define axes" -> axisDefinePane,
"Define marker" -> defineMarkerPane,
"Find Markers" -> findMarkerPane,
"Edit Markers" -> editMarkersPane,
"Results" -> finalResultPane
}
]
]

• This looks fantastic. I'll try it out when I get to work tomorrow. Apr 2, 2012 at 23:46
• This is great. The one thing I needed to do was map the coordinates from the image system to the axis system. I used {o, y, x} = {{31., 3.}, {32., 197.}, {357.328, 3.}}, and trans = FindGeometricTransform[{{400, 2.1}, {400, 2.7},{900, 2.1}}, {o, y, x}][[2]]. Then trans@res[[All, 2, 1]]. Apr 3, 2012 at 13:38
• @EliLansey Yeah, that's the way to go. Additionally, you could use res in a LocaterPane to manually adjust the automatically found settings and add points the method did not find. Apr 3, 2012 at 14:08
• @EliLansey See update. Wrapped it into a more complete app. Apr 4, 2012 at 12:19
• @EliLansey Small update. The last panel had some idle activity and I got rid of that, I localized a few forgotten variables and improved naming and did some miscellaneous clean-up. Apr 4, 2012 at 14:48

As per comments above, barChartDigitizer can be extended to {x,y} scatter plots.

scatterPlotDigitizer[g_Image] :=
DynamicModule[{ymin, yminValue = 0., ymax, ymaxValue = 1., xmin,
xminValue = 0., xmax, xmaxValue = 1., pt = {0, 0}, data = {},
img = ImageDimensions[g], output},

Deploy@Column[{
Row[{
Grid[{
{Button["Y Axis Min", ymin = pt[[2]]],
Button["Y Axis Max", ymax = pt[[2]]]},
{InputField[Dynamic[yminValue], Number, ImageSize -> 70],
InputField[Dynamic[ymaxValue], Number, ImageSize -> 70]},
{Button["X Axis Min", xmin = pt[[1]]],
Button["X Axis Max", xmax = pt[[1]]]},
{InputField[Dynamic[xminValue], Number, ImageSize -> 70],
InputField[Dynamic[xmaxValue], Number, ImageSize -> 70]}
}],
Button["Remove Last", data = Quiet@Check[Most@data, {}]]}],
Column[{Button["Start Over", data = {}],
Button["Print Output",
output =
Transpose[{Rescale[#, {xmin, xmax}, {xminValue,
xmaxValue}] & /@ data[[All, 1]],
Rescale[#, {ymin, ymax}, {yminValue, ymaxValue}] & /@
data[[All, 2]]}];
Print@Column[{ListPlot[output, ImageSize -> 400,
PlotRange -> {{xminValue, xmaxValue}, {yminValue,
ymaxValue}}], output}],
Enabled -> Dynamic[data =!= {}]]}]
}],
Row[{
Graphics[{Inset[
Image[g, ImageSize -> img]], {Tooltip[Locator[Dynamic[pt]],
Dynamic[pt]]}},
ImageSize -> img, PlotRange -> 1,
AspectRatio -> img[[2]]/img[[1]]]}]
}]
]


The steps to using this function are:

1. Copy the image of the plot you want to digitize and paste it as an argument to scatterPlotDigitizer.

2. Enter the minimum and maximum y axis values in the input fields.

3. Enter the minimum and maximum x axis values in the input fields.

4. Place the locator on the y minimum and click "Y Axis Min."

5. Place the locator on the y maximum and click "Y Axis Max."

6. Place the locator on the x minimum and click "X Axis Min."

7. Place the locator on the x maximum and click "X Axis Max."

8. Then place the locator over a point and click "Add point."

9. When you're done click "Print Output."

when applied to your plot you get:

data4 = {{401.5337423312884,
0.0159090909090909}, {450.6134969325154,
0.013181818181818173}, {501.2269938650307,
0.010757575757575744}, {548.7730061349694,
0.007272727272727254}, {600.920245398773,
0.00439393939393937}, {654.601226993865,
0.0024242424242423948}, {702.1472392638036,
0.0012121212121211783}, {800.3067484662575, \
-0.0003030303030303362}};

data5 = {{403.0674846625767,
0.007272727272727247}, {452.14723926380367,
0.005454545454545431}, {502.760736196319,
0.003939393939393916}, {551.840490797546,
0.002575757575757554}, {600.920245398773,
0.0015151515151514937}, {654.601226993865,
0.0007575757575757416}, {703.680981595092,
0.00030303030303028763}};

data6 = {{401.5337423312884,
0.005303030303030292}, {452.14723926380367,
0.003181818181818171}, {499.69325153374234,
0.001818181818181809}, {550.3067484662577,
0.0007575757575757486}, {602.4539877300613,
0.0001515151515151386}};

p2 = ListLinePlot[{data5, data4, data6},
Frame -> True,
FrameLabel -> {{"Extinction\ncoefficient (k)",
None}, {"Wavelength (nm)", None}},
FrameTicks -> {{{0.01, 0.02},
None}, {{400, 500, 600, 700, 800, 900}, None}},
FrameTicksStyle ->
Directive[FontFamily -> "Helevetica", 16, Black, Bold],
ImageSize -> 400,
ImagePadding -> {{90, 20}, {50, 1}},
LabelStyle -> Directive[FontFamily -> "Helevetica", 16, Black, Bold],
PlotRange -> {{xminValue, xmaxValue}, {0, 0.0225}},
PlotMarkers -> {
{Graphics[{EdgeForm[Directive[Thick, Thick]], Black,
Disk[{0, 0}, 1]}],
0.05}, {Graphics[{EdgeForm[Directive[Thick, Thick]], White,
Disk[{0, 0}, 1]}],
0.05}, {Graphics[{EdgeForm[Directive[Thick, Thick]], White,
Polygon[{{0, 0}, {0.5, 0.707}, {1, 0}}]}], 0.05}
},
PlotStyle -> Black]


and

data1 = {{401.5337423312883,
2.4784615384615387}, {449.07975460122697,
2.3984615384615386}, {499.6932515337423,
2.3400000000000003}, {550.3067484662575,
2.293846153846154}, {599.3865030674846,
2.263076923076923}, {651.5337423312883,
2.241538461538462}, {700.6134969325153,
2.2292307692307696}, {751.2269938650306,
2.216923076923077}, {800.3067484662577,
2.210769230769231}, {900., 2.201538461538462}};

data2 = {{401.5337423312884,
2.5237113402061855}, {449.079754601227,
2.4556701030927837}, {501.2269938650307,
2.4}, {548.7730061349694,
2.3597938144329897}, {599.3865030674847,
2.3288659793814435}, {651.5337423312883,
2.304123711340206}, {700.6134969325153,
2.288659793814433}, {749.6932515337423,
2.2731958762886597}, {798.7730061349694,
2.260824742268041}, {900., 2.245360824742268}};

data3 = {{400., 2.4494845360824744}, {449.0797546012271,
2.369072164948454}, {498.1595092024541,
2.316494845360825}, {548.7730061349694,
2.276288659793815}, {599.3865030674847,
2.239175257731959}, {651.5337423312884,
2.2144329896907218}, {699.079754601227,
2.205154639175258}, {749.6932515337423,
2.1958762886597936}, {800.3067484662577,
2.1896907216494843}, {898.4662576687116, 2.183505154639175}};

p1 = ListLinePlot[{data1, data2, data3},
Epilog -> {Inset[
Style["Starting material TiO:\nIonised oxygen",
FontFamily -> "Helevetica", 14, Black, Bold],
ImageScaled[{0.55, .82}], {Left, Top}]},
Frame -> True,
FrameLabel -> {{"Refractive\nIndex (n)", None}, {None, None}},
FrameTicks -> {{{2.1, 2.3, 2.5, 2.7}, None}, {None, None}},
FrameTicksStyle ->
Directive[FontFamily -> "Helevetica", 16, Black, Bold],
ImageSize -> 400,
ImagePadding -> {{90, 20}, {7, 10}},
LabelStyle -> Directive[FontFamily -> "Helevetica", 16, Black, Bold],
PlotRange -> {{xminValue, xmaxValue}, {yminValue, ymaxValue}},
PlotMarkers -> {
{Graphics[{EdgeForm[Directive[Thick, Thick]], Black,
Disk[{0, 0}, 1]}],
0.05}, {Graphics[{EdgeForm[Directive[Thick, Thick]], White,
Disk[{0, 0}, 1]}],
0.05}, {Graphics[{EdgeForm[Directive[Thick, Thick]], White,
Polygon[{{0, 0}, {0.5, 0.707}, {1, 0}}]}], 0.05}
},
PlotStyle -> Black]


which can be combined to give:

Grid[{{p1}, {p2}}, Spacings -> 0]


I have used ListLinePlot to join the dots simply to show this working but your chart appears to have fitted lines (most notable in the bottom chart) ...which you could add. I haven't bothered to change the tick lengths or adding the arrows, aspect ratio etc.

This is of course is a time consuming way of extracting points but it works. Also if the image is distorted you can probably fix this using some of the corrective measures described by others in the Q&A that you linked to.

• I am not sure what I'm doing wrong here, but I set the origin values (clicking the buttons after entering the values), then center the locator over each point, and click "Add point." When I've done that for each point, I click "Print Output," but it spits out a List of {Indeterminate,Indeterminate}. Apr 3, 2012 at 13:35
• just added the steps -- which I should have written in the first place. Apr 3, 2012 at 21:39
• I like this for things where a more automated approach won't work Apr 4, 2012 at 13:19

For simple cases, where a manual method is enough, I do the following:

Then, with the help of get coordinates (from the context menu):

imageCut = ImageTrim[image, {{96, 222}, {421, 417}}]


Followed by:

range = {{400, 900}, {2.1, 2.7}};
Graphics[Inset[imageCut, Scaled[{0, 0}], {0, 0}, Scaled[{1, 1}]],
PlotRange -> range, AspectRatio -> ImageAspectRatio[imageCut],
ImageSize -> 400, Frame -> True, Axes -> False,


And then you can easily use the Get Coordinates

I know this I not perfect, neither complete. The following post talks a little more on the subject Link.

• This is the same issue as with vucko's answer. I'd prefer not to do it manually. Apr 2, 2012 at 19:26
• @EliLansey I agree with you, but sometime not even the best software to find waldo can be more intelligent than the human analysis (not the case, but it depends to what limit you want to go). I think that, starting from my basis, and adding locators to define a search area/envelope (again, by hand), plus a statistical analysis on the points location existing inside the envelope can do the trick (unless you really want hands off technology, which with the number of artifacts your graphic has, clearly would be beyond my skills). Apr 2, 2012 at 19:38

Have you tried...

img = "image file";
lines = ImageLines[EdgeDetect[img, 13], .18];
Show[img, Graphics[{Thick, Red, Line /@ lines}]]

• Yes, doesn't work. Apr 3, 2012 at 13:15

If you have to extract the data of only this plot, then you can use Graphics->Drawing Tools and use Get Coordinates. You can then click on all the points of interest in the figure to mark the coordinates and Cmd+C to copy marked coordinates to the clipboard.

• This is a more general question. This is one example dataset. In principle, I'd like to do this for others, as well. Apr 2, 2012 at 14:10
• Also, the manual approach will be highly sensitive to manual shakiness when getting coordinates. Apr 2, 2012 at 14:13