Merge pull request #50 from gluxon/master

Use GitHub Flavored Markdown for JavaScript code and bash

README.md

@@ -13,31 +13,31 @@ You'll need OpenCV 2.3.1 installed.
 
 Then:
 
-
-        npm install opencv
-
+```bash
+$ npm install opencv
+```
 
 Or to build the repo:
 
-
-        node-gyp rebuild
-
+```bash
+$ node-gyp rebuild
+```
 
 ## Examples
 
 ### Face Detection
 
-
-        cv.readImage("./examples/test.jpg", function(err, im){
-          im.detectObject(cv.FACE_CASCADE, {}, function(err, faces){
-            for (var i=0;i<faces.length; i++){
-              var x = faces[i]
-              im.ellipse(x.x + x.width/2, x.y + x.height/2, x.width/2, x.height/2);
-            }
-            im.save('./out.jpg');
-          });
-        })
-
+```javascript
+cv.readImage("./examples/test.jpg", function(err, im){
+  im.detectObject(cv.FACE_CASCADE, {}, function(err, faces){
+    for (var i=0;i<faces.length; i++){
+      var x = faces[i]
+      im.ellipse(x.x + x.width/2, x.y + x.height/2, x.width/2, x.height/2);
+    }
+    im.save('./out.jpg');
+  });
+})
+```
 
 
 ## API Documentation
@@ -49,42 +49,52 @@ base datastructure in OpenCV. Things like images are just matrices of pixels.
 
 #### Creation
 
-        new Matrix(rows, cols)
+```javascript
+new Matrix(rows, cols)
+```
 
 Or if you're thinking of a Matrix as an image:
 
-        new Matrix(height, width)
+```javascript
+new Matrix(height, width)
+```
 
 Or you can use opencv to read in image files. Supported formats are in the OpenCV docs, but jpgs etc are supported.
 
-        cv.readImage(filename, function(mat){
-          ...
-        })
+```javascript
+cv.readImage(filename, function(mat){
+  ...
+})
 
-        cv.readImage(buffer, function(mat){
-          ...
-        })
+cv.readImage(buffer, function(mat){
+  ...
+})
+```
 
 If you need to pipe data into an image, you can use an ImageDataStream:
 
-        var s = new cv.ImageDataStream()
+```javascript
+var s = new cv.ImageDataStream()
 
-        s.on('load', function(matrix){
-          ...
-        })
+s.on('load', function(matrix){
+  ...
+})
 
-        fs.createReadStream('./examples/test.jpg').pipe(s);
+fs.createReadStream('./examples/test.jpg').pipe(s);
+```
 
 If however, you have a series of images, and you wish to stream them into a
 stream of Matrices, you can use an ImageStream. Thus:
 
-        var s = new cv.ImageStream()
+```javascript
+var s = new cv.ImageStream()
 
-        s.on('data', function(matrix){
-           ...
-        })
+s.on('data', function(matrix){
+   ...
+})
 
-        ardrone.createPngStream().pipe(s);
+ardrone.createPngStream().pipe(s);
+```
 
 Note: Each 'data' event into the ImageStream should be a complete image buffer.
 
@@ -92,36 +102,42 @@ Note: Each 'data' event into the ImageStream should be a complete image buffer.
 
 #### Accessing Data
 
-        var mat = new cv.Matrix.Eye(4,4); // Create identity matrix
+```javascript
+var mat = new cv.Matrix.Eye(4,4); // Create identity matrix
 
-        mat.get(0,0) // 1
-
-        mat.row(0)  // [1,0,0,0]
-        mat.col(4)  // [0,0,0,1]
+mat.get(0,0) // 1
 
+mat.row(0)  // [1,0,0,0]
+mat.col(4)  // [0,0,0,1]
+```
 
 ##### Save
 
-        mat.save('./pic.jpg')
+```javascript
+mat.save('./pic.jpg')
+```
 
 or:
 
-        var buff = mat.toBuffer()
-
+```javascript
+var buff = mat.toBuffer()
+```
 
 #### Image Processing
 
-        im.convertGrayscale()
-        im.canny(5, 300)
-        im.houghLinesP()
-
+```javascript
+im.convertGrayscale()
+im.canny(5, 300)
+im.houghLinesP()
+```
 
 
 #### Simple Drawing
 
-        im.ellipse(x, y)
-        im.line([x1,y1], [x2, y2])
-
+```javascript
+im.ellipse(x, y)
+im.line([x1,y1], [x2, y2])
+```
 
 #### Object Detection
 
@@ -129,21 +145,25 @@ There is a shortcut method for
 [Viola-Jones Haar Cascade](http://www.cognotics.com/opencv/servo_2007_series/part_2/sidebar.html) object 
 detection. This can be used for face detection etc.
 
-
-        mat.detectObject(haar_cascade_xml, opts, function(err, matches){})
+```javascript
+mat.detectObject(haar_cascade_xml, opts, function(err, matches){})
+```
 
 For convenience in face recognition, cv.FACE_CASCADE is a cascade that can be used for frontal face recognition.
 
 Also:
 
-        mat.goodFeaturesToTrack
-
+```javascript
+mat.goodFeaturesToTrack
+```
 
 #### Contours
 
-        mat.findCountours
-        mat.drawContour
-        mat.drawAllContours
+```javascript
+mat.findCountours
+mat.drawContour
+mat.drawAllContours
+```
 
 ### Using Contours
 
@@ -151,33 +171,35 @@ Also:
 functions for accessing, computing with, and altering the contours contained in it.
 See [relevant source code](src/Contours.cc) and [examples](examples/)
 
-        var contours = im.findContours;
+```javascript
+var contours = im.findContours;
 
-        # Count of contours in the Contours object
-        contours.size();
+# Count of contours in the Contours object
+contours.size();
 
-        # Count of corners(verticies) of contour `index`
-        contours.cornerCount(index);
+# Count of corners(verticies) of contour `index`
+contours.cornerCount(index);
 
-        # Access vertex data of contours
-        for(var c = 0; c < contours.size(); ++c) {
-          console.log("Contour " + c);
-          for(var i = 0; i < contours.cornerCount(c); ++i) {
-            var point = contours.point(c, i);
-            console.log("(" + point.x + "," + point.y + ")");"
-          }
-        }
+# Access vertex data of contours
+for(var c = 0; c < contours.size(); ++c) {
+  console.log("Contour " + c);
+  for(var i = 0; i < contours.cornerCount(c); ++i) {
+    var point = contours.point(c, i);
+    console.log("(" + point.x + "," + point.y + ")");"
+  }
+}
 
-        # Computations of contour `index`
-        contours.area(index);
-        contours.arcLength(index, isClosed);
-        contours.boundingRect(index);
-        contours.minAreaRect(index);
-        contours.isConvex(index);
+# Computations of contour `index`
+contours.area(index);
+contours.arcLength(index, isClosed);
+contours.boundingRect(index);
+contours.minAreaRect(index);
+contours.isConvex(index);
 
-        # Destructively alter contour `index`
-        contours.approxPolyDP(index, epsilon, isClosed);
-        contours.convexHull(index, clockwise);
+# Destructively alter contour `index`
+contours.approxPolyDP(index, epsilon, isClosed);
+contours.convexHull(index, clockwise);
+```
 
 ## MIT License
 The library is distributed under the MIT License - if for some reason that