Added Neural network code
This commit is contained in:
@@ -0,0 +1,335 @@
|
||||
// avansvisionlib - Growing Visionlibrary of Avans based on OpenCV 2.4.10
|
||||
// Goal: deep understanding of vision algorithms by means of developing own (new) algorithms.
|
||||
// deep understanding of neural networks
|
||||
//
|
||||
// Copyright Jan Oostindie, version 2.0 dd 5-12-2016 (= Neural Network (BPN) added to version 1.0 dd 5-11-2016.)
|
||||
// Contains basic functions to perform calculations on matrices/images of class Mat. Including BLOB labeling functions
|
||||
// Contains a BPN neural network.
|
||||
// Note: Students of Avans are free to use this library in projects and for own vision competence development. Others may ask permission to use it by means
|
||||
// of sending an email to Jan Oostindie, i.e. jac.oostindie@avans.nl
|
||||
#pragma once
|
||||
#include <opencv2/core/core.hpp>
|
||||
#include <opencv2/highgui/highgui.hpp>
|
||||
#include <opencv/cv.h>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
|
||||
using namespace cv;
|
||||
using namespace std;
|
||||
|
||||
// remark: a function call with a Mat-object parameter is a call by reference
|
||||
|
||||
/*********************** PROTOTYPES of the function library ************************/
|
||||
|
||||
// func: setup a specified entry (i,j) of a matrix m with a specific value
|
||||
// pre: (i < m.rows) & (j < m.cols)
|
||||
void setEntry(Mat m, int i, int j, double value);
|
||||
|
||||
// func: get the value of a specified entry (i,j) of a matrix m
|
||||
// pre: (i < m.rows) & (j < m.cols)
|
||||
// return: <return_value> == m(i,j)
|
||||
double getEntry(Mat m, int i, int j);
|
||||
|
||||
// func: calculate product of a row and column of equal length
|
||||
// pre: (row.cols == col.rows) & (row.rows == 1) & (col.cols == 1)
|
||||
double inproduct(Mat row, Mat col);
|
||||
|
||||
// func: prints matrix m in the console
|
||||
// pre: true
|
||||
void printMatrix(Mat m);
|
||||
|
||||
// func: select and get a row of a matrix m. rowNr contains the row number
|
||||
// pre: 0 < rowNr < m.rows
|
||||
// return: <result matrix> contains the selected row
|
||||
Mat getRow(Mat m, int rowNr);
|
||||
|
||||
// func: get a column of a matrix m. colNr contains the column number
|
||||
// pre: 0 < colNr < m.cols
|
||||
// return: <result matrix> contains the selected column
|
||||
Mat getCol(Mat m, int colNr);
|
||||
|
||||
// func: multiply two matrices a and b
|
||||
// pre: (a.cols == b.rows)
|
||||
// return: <result matrix>.rows == b.rows & <result matrix>.cols == b.cols
|
||||
Mat multiply(Mat a, Mat b);
|
||||
|
||||
// pre: matrices have equal dimensions i.e. (a.cols == b.cols) & (a.rows == b.rows)
|
||||
// return: <result matrix>(i,j) == a(i,j) + b(i,j) for all (0,0) <= (i,j) < (a.rows,a.cols)
|
||||
Mat add(Mat a, Mat b);
|
||||
|
||||
// func: transposes a matrix
|
||||
// return: <return_matrix>(i,j) = m(j,i) & <return_matrix>.rows = m.cols & <return_matrix>.cols = m.rows
|
||||
Mat transpose(Mat m);
|
||||
|
||||
// func: sets all entries of a matrix to a certain value
|
||||
// pre: true
|
||||
void setValue(Mat m, double value);
|
||||
|
||||
// func: generates a randomvalue between min and max
|
||||
// pre: true
|
||||
double generateRandomValue(double min, double max);
|
||||
|
||||
|
||||
// func: sets all entries of a matrix to a random value
|
||||
// pre: true
|
||||
void setRandomValue(Mat m, double min, double max);
|
||||
|
||||
|
||||
|
||||
/*********************************** Image operaties ****************************************/
|
||||
// NB images are supposed to have 1 channel (B/W image) and depth 16 bits signed (CV_16S)
|
||||
/********************************************************************************************/
|
||||
|
||||
// func: setup a specified entry (i,j) of a matrix m with a specific value
|
||||
// pre: (i < m.rows) & (j < m.cols)
|
||||
void setEntryImage(Mat m, int i, int j, _int16 value);
|
||||
|
||||
// func: get the value of a specified entry (i,j) of a matrix m
|
||||
// pre: (i < m.rows) & (j < m.cols)
|
||||
// return: <return_value> == m(i,j)
|
||||
_int16 getEntryImage(Mat m, int i, int j);
|
||||
|
||||
// func: calculate product of a row and column of equal length
|
||||
// pre: (row.cols == col.rows) & (row.rows == 1) & (col.cols == 1)
|
||||
_int16 inproductImage(Mat row, Mat col);
|
||||
|
||||
// func: select and get a row of a matrix m. rowNr contains the row number
|
||||
// pre: 0 < rowNr < m.rows
|
||||
// return: <result matrix> contains the selected row
|
||||
Mat getRowImage(Mat m, int rowNr);
|
||||
|
||||
// func: get a column of a matrix m. colNr contains the column number
|
||||
// pre: 0 < colNr < m.cols
|
||||
// return: <result matrix> contains the selected column
|
||||
Mat getColImage(Mat m, int colNr);
|
||||
|
||||
// func: multiply two matrices a and b
|
||||
// pre: (a.cols == b.rows)
|
||||
// return: <result matrix>.rows == b.rows & <result matrix>.cols == b.cols
|
||||
Mat multiplyImage(Mat a, Mat b);
|
||||
|
||||
// pre: matrices have equal dimensions i.e. (a.cols == b.cols) & (a.rows == b.rows)
|
||||
// return: <result matrix>(i,j) == a(i,j) + b(i,j) for all (0,0) <= (i,j) < (a.rows,a.cols)
|
||||
Mat addImage(Mat a, Mat b);
|
||||
|
||||
|
||||
// func: searches the maximum pixel value in the image
|
||||
// return: maximum pixel value
|
||||
_int16 maxPixelImage(Mat m);
|
||||
|
||||
// func: searches the minimum pixel value in the image
|
||||
// return: minimum pixel value
|
||||
_int16 minPixelImage(Mat m);
|
||||
|
||||
// func: determines the range of the image, i.e. the minimum
|
||||
// and maximum pixel value in the image
|
||||
// post: range = minPixelValue, maxPixelValue
|
||||
void getPixelRangeImage(Mat m, _int16 &minPixelValue, _int16 &maxPixelValue);
|
||||
|
||||
// func: transform scale the image
|
||||
// return: maximum pixel value
|
||||
void stretchImage(Mat m, _int16 minPixelValue, _int16 maxPixelValue);
|
||||
|
||||
// func: shows a 16S image on the screen. All values mapped on the interval 0-255
|
||||
/// pre: m is a 16S image (depth 16 bits, signed)
|
||||
void show16SImageStretch(Mat m, string windowTitle = "show16SImageStretch");
|
||||
|
||||
|
||||
// func: shows a 16S image on the screen. All values clipped to the interval 0-255
|
||||
// i.e. value < 0 => 0; 0 <= value <= 255 => value ; value > 255 => 255
|
||||
/// pre: m is a 16S image (depth 16 bits, signed)
|
||||
void show16SImageClip(Mat m, string windowTitle = "show16SImageClip");
|
||||
|
||||
|
||||
|
||||
// func: histogram gamma correction
|
||||
// pre: image has depth 8 bits unsigned and 1 or 3 channels
|
||||
// post: entry(i,j) = 255*power(entry@pre(i,j)/255)^gamma
|
||||
void gammaCorrection(Mat image, float gamma);
|
||||
|
||||
|
||||
// func: makes a administration used for labeling blobs.
|
||||
// the function adds a edge of 1 pixel wide tot a binary image, all with value 0.
|
||||
// All 1's are made -1. The result is returned.
|
||||
// This function is used by function labelBLOBs
|
||||
// pre : binaryImage has depth 16 bits signed int. Contains only values 0 and 1.
|
||||
// return_matrix: All "1" are made "-1" meaning value 1 and unvisited.
|
||||
Mat makeAdmin(Mat binaryImage);
|
||||
|
||||
|
||||
// func: Searches the next blob after position (row,col)
|
||||
// post: if return_value == 1 then (row,col) contains the position
|
||||
// where the next blob starts.
|
||||
// return_value: true => blob found ; starting position is (row,col)
|
||||
// false => no blob found ; (row, col) == (-1, -1)
|
||||
bool findNextBlob(Mat admin, int & row, int & col);
|
||||
|
||||
|
||||
// func: searches the first 1 when rotating around the pixel (currX,currY),
|
||||
// starting at position 0. Definition of relative positions:
|
||||
// 7 0 1
|
||||
// 6 X 2
|
||||
// 5 4 3
|
||||
void findNext1(Mat admin, int & currX, int & currY, int & next1);
|
||||
|
||||
// func: gets the entry of a neighbour pixel with relative position nr.
|
||||
// Definition of relative positions nr:
|
||||
// 7 0 1
|
||||
// 6 X 2
|
||||
// 5 4 3
|
||||
_int16 getEntryNeighbour(const Mat & admin, int x, int y, int nr);
|
||||
|
||||
|
||||
// func: determines if there are more than 1 adjacent 1's
|
||||
bool moreNext1(const Mat & admin, int x, int y);
|
||||
|
||||
|
||||
|
||||
// func: labels all pixels of one blob which starts at position (row,col) with blobNr.
|
||||
// This function is used by function labelBLOB's which labels all blobs.
|
||||
// return_value: area of the blob
|
||||
// Evaluation: This function uses a iterative algorithm in which a special labeling technique is
|
||||
// is used which gives the opportunity to trace all individiual pixels. This makes it
|
||||
// possible for example to save only these pixels on disk or to translate the object in
|
||||
// in the image.
|
||||
// The disadvantagae however is that the algorithm is more complicated an maybe a little bit
|
||||
// slower than the recursive variant.
|
||||
int labelIter(Mat & admin, int row, int col, int blobNr);
|
||||
|
||||
|
||||
// func: labels all pixels of one blob which starts at position (row,col) with blobNr.
|
||||
// return_value: area of the blob
|
||||
// Evaluation: This function uses a recursive algorithm which has the advantage that it is easy and trasparent.
|
||||
// The disadvantagae however is that it claims a lot of spacee on the stack. I.e. every found
|
||||
// pixel results in a function call which in case of large blobs causes a stack overflow.
|
||||
int labelRecursive(Mat & admin, int row, int col, int blobNr);
|
||||
|
||||
// func: retrieves a labeledImage from the labeling administration
|
||||
// pre : admin is contains labeled pixels with neighbour number information.
|
||||
// post: labeledImage: binary 8-connected pixels with value 1 in binaryImage are
|
||||
// labeled with the number of the object they belong to.
|
||||
void retrieveLabeledImage(const Mat & admin, Mat & labeledImage);
|
||||
|
||||
// func: labeling of all blobs in a binary image
|
||||
// pre : binaryImage has depth 16 bits signed int. Contains only values 0 and 1.
|
||||
// post: labeledImage: binary 8-connected pixels with value 1 in binaryImage are
|
||||
// labeled with the number of the object they belong to.
|
||||
// return_value: the total number of objects.
|
||||
int labelBLOBs(Mat binaryImage, Mat & labeledImage);
|
||||
|
||||
|
||||
// func: labeling of all blobs in a binary image with a area in [threshAreaMin,threshAreaMax]. Default
|
||||
// threshold is [1,INT_MAX]. Alle gathered data during the labeling proces is returned,
|
||||
// i.e. the positions of the firstpixel of each blob, the position of the blobs (i.e. the
|
||||
// centres of gravity) and the area's of all blobs.
|
||||
// pre : binaryImage has depth 16 bits signed int. Contains only values 0 and 1.
|
||||
// post: labeledImage: binary 8-connected pixels with value 1 in binaryImage are
|
||||
// labeled with the number of the object they belong to.
|
||||
// areaVec: contains all area's of the blobs. The index corresponds to the number
|
||||
// of the blobs. Index 0 has no meaning.
|
||||
// return_value: the total number of objects.
|
||||
int labelBLOBsInfo(Mat binaryImage, Mat & labeledImage,
|
||||
vector<Point2d *> & firstpixelVec, vector<Point2d *> & posVec,
|
||||
vector<int> & areaVec,
|
||||
int threshAreaMin = 1, int threshAreaMax = INT_MAX);
|
||||
|
||||
|
||||
/*****************************************************************************************************************************************************/
|
||||
/*BEGIN********************************************** BACK PROPAGATION NEURAL NETWORK ****************************************************************/
|
||||
/*****************************************************************************************************************************************************/
|
||||
|
||||
// func: loads an example of a training set
|
||||
// pre: true
|
||||
// post: ITset input training set. Each row contains a number of features.
|
||||
// OTset output training set. Each row contains the expected output belonging to the corresponding row of features in the input training set.
|
||||
//
|
||||
// TRAININGSET: I0 because of bias V0
|
||||
//
|
||||
// setnr I0 I1 I2 I3 I4 O1 O2
|
||||
// 1 1.0 0.4 -0.7 0.1 0.71 0.0 0.0
|
||||
// 2 1.0 0.3 -0.5 0.05 0.34 0.0 0.0
|
||||
// 3 1.0 0.6 0.1 0.3 0.12 0.0 1.0
|
||||
// 4 1.0 0.2 0.4 0.25 0.34 0.0 1.0
|
||||
// 5 1.0 -0.2 0.12 0.56 1.0 1.0 0.0
|
||||
// 6 1.0 0.1 -0.34 0.12 0.56 1.0 0.0
|
||||
// 7 1.0 -0.6 0.12 0.56 1.0 1.0 1.0
|
||||
// 8 1.0 0.56 -0.2 0.12 0.56 1.0 1.0
|
||||
void loadTrainingSet1(Mat & ITset, Mat & OTset);
|
||||
|
||||
|
||||
// func: loads an example of a training set in which only binary numbers are used.
|
||||
// pre: true
|
||||
// post: ITset input training set. Each row contains a number of binary numbers.
|
||||
// OTset output training set. Each row contains the expected output belonging to the corresponding row of binary numbers in the input training set.
|
||||
//
|
||||
// TRAININGSET binary function O1 = (I1 OR I2) AND I3
|
||||
// without bias
|
||||
// setnr I1 I2 I3 O1
|
||||
// 1 0 0 0 0
|
||||
// 2 0 0 1 0
|
||||
// 3 0 1 0 0
|
||||
// 4 0 1 1 1
|
||||
// 5 1 0 0 0
|
||||
// 6 1 0 1 1
|
||||
// 7 1 1 0 0
|
||||
// 8 1 1 1 1
|
||||
void loadBinaryTrainingSet1(Mat & ITset, Mat & OTset);
|
||||
|
||||
|
||||
// func: Initialization of the (1) weigthmatrices V0 and W0 and (2) of the delta matrices dV0 and dW0.
|
||||
// pre: inputNeurons, hiddenNeurons and outputNeurons define the Neural Network.
|
||||
// (from these numbers the dimensions of the weightmatrices can be determined)
|
||||
// post: V0 and W0 have random values between 0.1 and 0.9
|
||||
void initializeBPN(int inputNeurons, int hiddenNeurons, int outputNeurons,
|
||||
Mat & V0, Mat & dV0, Mat & W0, Mat & dW0);
|
||||
|
||||
|
||||
// Test of a BPN with all values defined explicitly.
|
||||
// pre: true
|
||||
// post: IT is the input training set ; OT is the corresponding output training set. ; V0, W0 are the weight matrices of a BPN with 1 hidden layer;
|
||||
// dV0, dW0 are the initial delta matrices of the weight factor matrices.
|
||||
void testBPN(Mat & IT, Mat & OT, Mat & V0, Mat & dV0, Mat & W0, Mat & dW0);
|
||||
|
||||
// func: Given an inputvector of the inputlayer and a weightmatrix V calculates the outputvector of the hiddenlayer
|
||||
// pre: II is input of the inputlayer. V = matrix with weightfactors between inputlayer and the hiddenlayer.
|
||||
// post: OH is the outputvector of the hidden layer
|
||||
void calculateOutputHiddenLayer(Mat II, Mat V, Mat & OH);
|
||||
|
||||
|
||||
// func: Given the outputvector of the hiddenlayer and a weigthmatrix W calculates the outputvector of the outputlayer
|
||||
// pre: OH is the outputvector of the hiddenlayer. W = matrix with weightfactors between hiddenlayer and the outputlayer.
|
||||
// post: OO is the outputvector of the output layer
|
||||
void calculateOutputBPN(Mat OH, Mat W, Mat & OO);
|
||||
|
||||
|
||||
// func: Calculates the total error Error = 1/2*Sigma(OTi-OOi)^2.
|
||||
// OTi is the expected output according to the trainingvector i
|
||||
// OOi is the calculated output from the current neural network of the traininngvector i
|
||||
// pre: OO is the outputvector of the outputlayer. OT is the expected outputvector from the trainingset
|
||||
// post: OO is the outputvector of the output layer
|
||||
void calculateOutputBPNError(Mat OO, Mat OT, double & outputError);
|
||||
|
||||
|
||||
// func: calculates the updates of the weight factor matrices V0 and W0 on basics of the calculated output matrix and the expected output matrix.
|
||||
// A back propagation algorithm is used.
|
||||
// pre: OT is the expected outputvector from the trainingset ; OO is the calculated outputvector of the outputlayer ;
|
||||
// OH is the calculated output of the hiddenlayer ; OI is the output of the inputlayer (normaly equal to the input of the inputlayer)
|
||||
// V0 is the weight matrix between the input layer and the hidden layer ; W0 is the weight matrix between the hiddenlayer and the output layer.
|
||||
// dV0, dW0 are the correction matrices.
|
||||
// post: V is the adapted weight matrix between the inputlayer and the hidden layer ; W is the weight matrix between the hiddenlayer and the output layer.
|
||||
void adaptVW(Mat OT, Mat OO, Mat OH, Mat OI, Mat W0, Mat dW0, Mat V0, Mat dV0, Mat & W, Mat & V,
|
||||
double ALPHA = 1.0, double ETHA = 0.6);
|
||||
|
||||
|
||||
// func: given an inputvector calculates the output of a BPN with weigth matrices V and W.
|
||||
// pre: II is the input vector of the BPN ;
|
||||
// V is the weight factor matrix between the input layer and the hidden layer
|
||||
// W is the weight factor matrix between the hidden layer and the output layer
|
||||
// return: output vector
|
||||
Mat BPN(Mat II, Mat V, Mat W);
|
||||
|
||||
|
||||
/*****************************************************************************************************************************************************/
|
||||
/*END********************************************** BACK PROPAGATION NEURAL NETWORK ******************************************************************/
|
||||
/*****************************************************************************************************************************************************/
|
||||
|
||||
Reference in New Issue
Block a user