Optasia wrapper for LPR processor

13. public class LPRProcessor : Processor
14.     {
15.         public override IEnumerable<Row> Process(RowSet input, Row outputRow, string[] args)
16.         {
17.             //Initialize the LPR processor
18.             LPRwrapperM lp = new LPRwrapperM(args[0], args[1]);
19.  
20.             //For each input row corresponding to an image patch, detect the lincense plates
21.             foreach (Row row in input.Rows)
22.             {
23.                 //Read image binary from the last column
24.                 byte[] ary1 = row[row.Count - 1].Binary;
25.                  
26.                 //Initilize the image
27.                 img im = new img(ary1, ary1.Length, 1);
28.                 //Call LPR
29.                 List<problpM> lps = lp.getLPs(im, 0.85f);
30.                 //Return probabilistic LPR results
31.                 foreach (var item in lps)
32.                 {
33.                     outputRow[0].Set(row[0].Integer);
34.                     outputRow[1].Set(row[1].Integer);
35.                     outputRow[2].Set(item.getLP());
36.                     outputRow[3].Set((float)item.getProb());
37.                     yield return outputRow;
38.                 }
39.             }
40.         }
41.     }

Optasia wrapper for classifier processor

14. public class ClassifierProcessor : Processor
15.     {  
16.         public override IEnumerable<Row> Process(RowSet input, Row outputRow, string[] args)
17.         {
18.             //Initialize the classifier
19.             classifierM c = new classifierM(CLAS.LIBLINEAR, args[0]);
20.  
21.             //For each input row corresponding to a feature vector, apply the classifier
22.             foreach (Row row in input.Rows)
23.             {
24.                 //Decode double vector
25.                 List<float> feat = Optasia.Decode(row[row.Count - 1].Binary);
26.                 //Call the classifier
27.                 var result = c.predict(feat);
28.                 //Return probabilistic results
29.                 foreach (var pair in result)
30.                 {
31.                     outputRow[0].Set((int)row[0].Value);
32.                     outputRow[1].Set((int)row[1].Value);
33.                     outputRow[2].Set(pair.Key);
34.                     outputRow[3].Set(pair.Value);
35.                     yield return outputRow;
36.                 }
37.             }
38.         }
39.     }

Optasia wrapper for tracking reducer

11. public class TrackingReducer : Reducer
12.     {
13.         public override IEnumerable<Row> Reduce(RowSet input, Row outputRow, string[] args)
14.         {
15.             bool init = false;
16.             //Initialize the tracking module
17.             TrackingWrapperM t = new TrackingWrapperM(args[0].Split(',').ToList(),
18.                 args[1].Split(',').ToList(), args[2].Split(',').ToList());
19.             //For each input row corresponding to a new image frame, run the tracking
20.             foreach (Row row in input.Rows)
21.             {
22.                 List<carM> results = new List<carM>();
23.                 img im = new img(row[row.Count - 1].Binary, row[row.Count - 1].Binary.Length, 1);
24.  
25.                 if (!init) //Construct first-frame reference
26.                 {
27.                     t.init(im);
28.                     init = true;
29.                 }
30.                 else //Call the tracking module
31.                     results = t.run(im);
32.  
33.                 //Return all tracking records
34.                 foreach (var item in results)
35.                 {
36.                     outputRow[0].Set(row[0].Integer);
37.                     outputRow[1].Set(row[1].Integer);
38.                     outputRow[2].Set(item.data);
39.                     outputRow[3].Set(item.inbox);
40.                     outputRow[4].Set(item.inFrameId);
41.                     outputRow[5].Set(item.outbox);
42.                     outputRow[6].Set(item.outFrameId);
43.  
44.                     yield return outputRow;
45.                 }
46.             }
47.         }
48.     }