Port readme changes to template

novedevo · web-flow · commit 3a10958a21a0 · 2022-10-11T10:16:25.000-07:00
diff --git a/doc-template/readme.template.md b/doc-template/readme.template.md
@@ -1,4 +1,4 @@
-# Plotters - A Rust drawing library focus on data plotting for both WASM and native applications  🦀📈🚀
+# Plotters - A Rust drawing library focusing on data plotting for both WASM and native applications 🦀📈🚀
 
 <a href="https://crates.io/crates/plotters">
     <img style="display: inline!important" src="https://img.shields.io/crates/v/plotters.svg"></img>
@@ -13,14 +13,14 @@
 	<img style="display: inline! important" src="https://img.shields.io/badge/docs-development-lightgrey.svg"></img>
 </a>
 
-Plotters is drawing library designed for rendering figures, plots, and charts, in pure rust. Plotters supports various types of back-ends, 
+Plotters is a drawing library designed for rendering figures, plots, and charts, in pure Rust. Plotters supports various types of back-ends, 
 including bitmap, vector graph, piston window, GTK/Cairo and WebAssembly. 
 
-- A new Plotters Developer's Guide is working in progress. The preview version is available at [here](https://plotters-rs.github.io/book).
-- To try Plotters with interactive Jupyter notebook, or view [here](https://plotters-rs.github.io/plotters-doc-data/evcxr-jupyter-integration.html) for the static HTML version.
+- A new Plotters Developer's Guide is a work in progress. The preview version is available [here](https://plotters-rs.github.io/book).
+- Try Plotters with an interactive Jupyter notebook, or view [here](https://plotters-rs.github.io/plotters-doc-data/evcxr-jupyter-integration.html) for the static HTML version.
 - To view the WASM example, go to this [link](https://plotters-rs.github.io/wasm-demo/www/index.html)
-- Currently we have all the internal code ready for console plotting, but a console based backend is still not ready. See [this example](https://github.com/38/plotters/blob/master/examples/console.rs) for how to plotting on Console with a customized backend.
-- Plotters now moved all backend code to sperate repositories, check [FAQ list](#faq-list) for details
+- Currently we have all the internal code ready for console plotting, but a console based backend is still not ready. See [this example](https://github.com/38/plotters/blob/master/examples/console.rs) for how to plot on console with a customized backend.
+- Plotters has moved all backend code to separate repositories, check [FAQ list](#faq-list) for details
 - Some interesting [demo projects](#demo-projects) are available, feel free to try them out.
 
 ## Gallery
@@ -54,7 +54,7 @@ $$../examples/quick_start.rs$$
 
 ## Demo Projects
 
-To learn how to use Plotters in different scenarios by checking out the following demo projects:
+To learn how to use Plotters in different scenarios, check out the following demo projects:
 
 - WebAssembly + Plotters: [plotters-wasm-demo](https://github.com/plotters-rs/plotters-wasm-demo)
 - minifb + Plotters: [plotters-minifb-demo](https://github.com/plotters-rs/plotters-minifb-demo)
@@ -63,7 +63,7 @@ To learn how to use Plotters in different scenarios by checking out the followin
 
 ## Trying with Jupyter evcxr Kernel Interactively
 
-Plotters now supports integrate with `evcxr` and is able to interactively drawing plots in Jupyter Notebook.
+Plotters now supports integration with `evcxr` and is able to interactively draw plots in Jupyter Notebook.
 The feature `evcxr` should be enabled when including Plotters to Jupyter Notebook.
 
 The following code shows a minimal example of this.
@@ -104,7 +104,7 @@ figure
 
 ## Interactive Tutorial with Jupyter Notebook
 
-*This tutorial is now working in progress and isn't complete*
+*This tutorial is a work in progress and isn't complete*
 
 Thanks to the evcxr, now we have an interactive tutorial for Plotters!
 To use the interactive notebook, you must have Jupyter and evcxr installed on your computer. 
@@ -114,57 +114,55 @@ After that, you should be able to start your Jupyter server locally and load the
 
 ```bash
 git clone https://github.com/38/plotters-doc-data
-cd plotteres-doc-data
+cd plotters-doc-data
 jupyter notebook
 ```
 
 And select the notebook called `evcxr-jupyter-integration.ipynb`.
 
-Also, there's a static HTML version of this notebook available at the [this location](https://plotters-rs.github.io/plotters-doc-data/evcxr-jupyter-integration.html)
+Also, there's a static HTML version of this notebook available at [this location](https://plotters-rs.github.io/plotters-doc-data/evcxr-jupyter-integration.html)
 
 ## Plotting in Rust
 
-Rust is a perfect language for data visualization. Although there are many mature visualization libraries in many different languages.
-But Rust is one of the best languages fits the need.
+Rust is a perfect language for data visualization. Although there are many mature visualization libraries in many different languages, Rust is one of the best languages that fits the need.
 
 * **Easy to use** Rust has a very good iterator system built into the standard library. With the help of iterators,
-Plotting in Rust can be as easy as most of the high-level programming languages. The Rust based plotting library
+plotting in Rust can be as easy as most of the high-level programming languages. The Rust based plotting library
 can be very easy to use.
 
-* **Fast** If you need rendering a figure with trillions of data points, 
-Rust is a good choice. Rust's performance allows you to combine data processing step 
+* **Fast** If you need to render a figure with trillions of data points, 
+Rust is a good choice. Rust's performance allows you to combine the data processing step 
 and rendering step into a single application. When plotting in high-level programming languages,
 e.g. Javascript or Python, data points must be down-sampled before feeding into the plotting 
 program because of the performance considerations. Rust is fast enough to do the data processing and visualization 
 within a single program. You can also integrate the 
-figure rendering code into your application handling a huge amount of data and visualize it in real-time.
+figure rendering code into your application to handle a huge amount of data and visualize it in real-time.
 
-* **WebAssembly Support** Rust is one of few the language with the best WASM support. Plotting in Rust could be 
+* **WebAssembly Support** Rust is one of the languages with the best WASM support. Plotting in Rust could be 
 very useful for visualization on a web page and would have a huge performance improvement comparing to Javascript.
 
 ## Plotting on HTML5 canvas with WASM Backend
 
-Plotters currently supports backend that uses the HTML5 canvas. To use the WASM support, you can simply use 
+Plotters currently supports a backend that uses the HTML5 canvas. To use WASM, you can simply use 
 `CanvasBackend` instead of other backend and all other API remains the same!
 
 There's a small demo for Plotters + WASM available at [here](https://github.com/plotters-rs/plotters-wasm-demo). 
 To play with the deployed version, follow this [link](https://plotters-rs.github.io/wasm-demo/www/index.html).
 
-
 ## What types of figure are supported?
 
 Plotters is not limited to any specific type of figure.
 You can create your own types of figures easily with the Plotters API.
 
-But Plotters provides some builtin figure types for convenience.
+Plotters does provide some built-in figure types for convenience.
 Currently, we support line series, point series, candlestick series, and histogram.
 And the library is designed to be able to render multiple figure into a single image.
 But Plotter is aimed to be a platform that is fully extendable to support any other types of figure.
 
 ## Concepts by examples
 
-### Drawing Back-ends
-Plotters can use different drawing back-ends, including SVG, BitMap, and even real-time rendering. For example, a bitmap drawing backend.
+### Drawing Backends
+Plotters can use different drawing backends, including SVG, BitMap, and even real-time rendering. For example, a bitmap drawing backend.
 
 ```rust
 $$../examples/drawing_backends.rs$$
@@ -174,10 +172,10 @@ $$../examples/drawing_backends.rs$$
 
 ### Drawing Area
 Plotters uses a concept called drawing area for layout purpose.
-Plotters support multiple integrating into a single image.
+Plotters supports integrating multiple figures into a single image.
 This is done by creating sub-drawing-areas.
 
-Besides that, the drawing area also allows the customized coordinate system, by doing so, the coordinate mapping is done by the drawing area automatically.
+Besides that, the drawing area also allows for a customized coordinate system, by doing so, the coordinate mapping is done by the drawing area automatically.
 
 ```rust
 $$../examples/drawing_area.rs$$
@@ -187,7 +185,7 @@ $$../examples/drawing_area.rs$$
 
 ### Elements
 
-In Plotters, elements are build blocks of figures. All elements are able to draw on a drawing area.
+In Plotters, elements are the building blocks of figures. All elements are able to be drawn on a drawing area.
 There are different types of built-in elements, like lines, texts, circles, etc.
 You can also define your own element in the application code.
 
@@ -203,9 +201,9 @@ $$../examples/elements.rs$$
 
 ### Composable Elements
 
-Besides the built-in elements, elements can be composed into a logic group we called composed elements.
+Besides the built-in elements, elements can be composed into a logical group we called composed elements.
 When composing new elements, the upper-left corner is given in the target coordinate, and a new pixel-based 
-coordinate which has the upper-left corner defined as `(0,0)` is used for further element composition purpose.
+coordinate which has the upper-left corner defined as `(0,0)` is used for further element composition.
 
 For example, we can have an element which includes a dot and its coordinate.
 
@@ -217,7 +215,7 @@ $$../examples/composable_elements.rs$$
 
 ### Chart Context
 
-In order to draw a chart, Plotters need a data object built on top of the drawing area called `ChartContext`.
+In order to draw a chart, Plotters needs a data object built on top of the drawing area called `ChartContext`.
 The chart context defines even higher level constructs compare to the drawing area.
 For example, you can define the label areas, meshes, and put a data series onto the drawing area with the help
 of the chart context object.
@@ -266,13 +264,13 @@ Use `default_features = false` to disable those default enabled features,
 and then you should be able to cherry-pick what features you want to include into `Plotters` crate. 
 By doing so, you can minimize the number of dependencies down to only `itertools` and compile time is less than 6s.
 
-The following list is a complete list of features that can be opt in and out.
+The following list is a complete list of features that can be opted in or out.
 
 - Tier 1 drawing backends
 
 | Name    |  Description | Additional Dependency |Default?|
 |---------|--------------|--------|------------|
-| bitmap\_encoder  | Allow `BitMapBackend` save the result to bitmap files | image, rusttype, font-kit | Yes |
+| bitmap\_encoder  | Allow `BitMapBackend` to save the result to bitmap files | image, rusttype, font-kit | Yes |
 | svg\_backend     | Enable `SVGBackend` Support | None | Yes |
 | bitmap\_gif| Opt-in GIF animation Rendering support for `BitMapBackend`, implies `bitmap` enabled | gif | Yes |
 
@@ -318,7 +316,7 @@ The following list is a complete list of features that can be opt in and out.
 
 * How to draw text/circle/point/rectangle/... on the top of chart ?
 	
-	As you may realized, Plotters is a drawing library rather than a traditional data plotting library, 
+	As you may have realized, Plotters is a drawing library rather than a traditional data plotting library, 
 	you have the freedom to draw anything you want on the drawing area.
 	Use `DrawingArea::draw` to draw any element on the drawing area. 
 
@@ -332,10 +330,10 @@ The following list is a complete list of features that can be opt in and out.
 	- [HTML5 Canvas Backend](https://github.com/plotters-rs/plotters-canvas.git)
 	- [GTK/Cairo Backend](https://github.com/plotters-rs/plotters-cairo.git)
 
-* How to check if a backend writes file successfully ?
+* How to check if a backend writes to a file successfully ?
 
-	The behavior of Plotters backend is consistent with standard library. 
-    When the backend instance is being dropped, [`crate::drawing::DrawingArea::present()`] or `Backend::present()` is called automatically 
+	The behavior of Plotters backend is consistent with the standard library. 
+    When the backend instance is dropped, [`crate::drawing::DrawingArea::present()`] or `Backend::present()` is called automatically 
     whenever is needed. When the `present()` method is called from `drop`, any error will be silently ignored.
 
     In the case that error handling is important, you need manually call the `present()` method before the backend gets dropped.
