RetinaMultiProject.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using sb_cs;
using Tutorials_Common;
 
namespace Tutorial7_RetinaMultiProject
{
    class RetinaMultiProject
    {
        static SbError execute()
        {
            SbProject slice = null;
            SbProject hole = null;
            SbRoi roi = null;
            SbImage img = null;
            SbRes res_slice = null;
            SbRes res_hole = null;
            SbError err = SbError.SB_ERR_NONE;
 
            Console.WriteLine("Sb Init");
            err = Sb.Init("../../../sb.lic");
            if (err != SbError.SB_ERR_NONE)
            {
                Console.WriteLine("Sb.Init failed with error " + err);
                return err;
            }
 
            Console.WriteLine("Wait for license...");
            err = Common.WaitLicense();
            if (err != SbError.SB_ERR_NONE)
            {
                Console.WriteLine("SbLicense.WaitLicense failed with error " + err);
                goto FnExit;
            }
 
            String solution_file = "../../solution/tutorial_7_retina_multi_project." + SbDefines.SbSolutionExt;
            SbSolutionInfo solutionInfo = SbSolution.GetInfo(solution_file);
            if (solutionInfo == null || solutionInfo.Error() != SbError.SB_ERR_NONE)
            {
                err = solutionInfo == null ? SbError.SB_ERR_INSUFFICIENT_FREE_MEMORY : solutionInfo.Error();
                Console.WriteLine("SbSolution.GetInfo failed");
                goto FnExit;
            }
            else if (solutionInfo.projects.Length == 0)
            {
                err = SbError.SB_ERR_PROJECT_NOT_FOUND;
                Console.WriteLine("SbSolution.GetInfo no projects found");
                goto FnExit;
            }
            Console.WriteLine("SbSolutionInfo.GetInfo, found " + solutionInfo.projects.Length + " projects");
 
            slice = SbProject.Load(solution_file, solutionInfo.projects[0].uuid, SbProjectMode.SB_PROJECT_MODE_DETECTION_ONLY);
            if (slice == null || slice.Error() != SbError.SB_ERR_NONE)
            {
                err = slice == null ? SbError.SB_ERR_INSUFFICIENT_FREE_MEMORY : slice.Error();
                Console.WriteLine("SbProject.Load failed with error " + err);
                goto FnExit;
            }
 
            hole = SbProject.Load(solution_file, solutionInfo.projects[1].uuid, SbProjectMode.SB_PROJECT_MODE_DETECTION_ONLY);
            if (hole == null || hole.Error() != SbError.SB_ERR_NONE)
            {
                err = hole == null ? SbError.SB_ERR_INSUFFICIENT_FREE_MEMORY : hole.Error();
                Console.WriteLine("SbProject.Load failed with error " + err);
                goto FnExit;
            }
 
            SbFolder folder = SbFolder.Load("../../dataset", "png", true, 0);
            if (folder != null)
            {
                for (int i = 0; i < folder.files.Length; i++)
                {
                    // Load the image from file.
                    img = SbImage.Load(folder.files[i]);
                    if (img == null || img.Error() != SbError.SB_ERR_NONE)
                    {
                        Console.WriteLine("SbImage.Load " + folder.files[i] + " failed");
                        err = img == null ? SbError.SB_ERR_INSUFFICIENT_FREE_MEMORY : img.Error();
                        break;
                    }
 
                    // Create the ROI
                    roi = SbRoi.Create(img.Width(), img.Height());
                    if (roi == null || roi.Error() != SbError.SB_ERR_NONE)
                    {
                        Console.WriteLine("SbRoi.Create failed");
                        err = roi == null ? SbError.SB_ERR_INSUFFICIENT_FREE_MEMORY : roi.Error();
                        break;
                    }
 
                    // Set a rectangular ROI equal to image dimensions.
                    err = roi.SetRect(255, new SbRect(0, 0, img.Width(), img.Height()), true);
                    if (err != SbError.SB_ERR_NONE)
                    {
                        Console.WriteLine("SbRoi.SetRect failed with error " + err);
                        break;
                    }
 
                    err = slice.Detection(img, roi);
                    if (err != SbError.SB_ERR_NONE)
                    {
                        Console.WriteLine("SbProject.Detection failed with error " + err);
                        break;
                    }
 
                    // Get the results.
                    res_slice = slice.GetRes(false);
                    if (res_slice == null || slice.Error() != SbError.SB_ERR_NONE)
                    {
                        err = res_slice == null ? SbError.SB_ERR_INSUFFICIENT_FREE_MEMORY : slice.Error();
                        Console.WriteLine("SbProject.GetRes failed with error " + err);
                        break;
                    }
 
                    Console.WriteLine("    slice detection time=" + (res_slice.timeUs / 1000.0f) + "ms, " + res_slice.samples.Length + " slices found");
 
                    for (int j = 0; j < res_slice.samples.Length; ++j)
                    {
                        err = roi.SetRect(255, new SbRect(res_slice.samples[j].centre.x - 115, res_slice.samples[j].centre.y - 65, 230, 130), true);
                        if (err != SbError.SB_ERR_NONE)
                        {
                            Console.WriteLine("SbRoi.SetRect failed with error " + err);
                            break;
                        }
 
                        err = hole.Detection(img, roi);
                        if (err != SbError.SB_ERR_NONE)
                        {
                            Console.WriteLine("SbProject.Detection failed with error " + err);
                            break;
                        }
 
                        // Get the results.
                        res_hole = hole.GetRes(false);
                        if (res_hole == null || hole.Error() != SbError.SB_ERR_NONE)
                        {
                            err = res_hole == null ? SbError.SB_ERR_INSUFFICIENT_FREE_MEMORY : hole.Error();
                            Console.WriteLine("SbProject.GetRes failed with error " + err);
                            break;
                        }
                        Console.WriteLine("        slice " + j + ": hole detection time=" + (res_hole.timeUs / 1000.0f) + ", " + res_hole.samples.Length  + " holes found");
                        // Print the results
                        for (int k = 0; k < res_hole.samples.Length; ++k)
                            Console.WriteLine("            centre=(" + res_hole.samples[k].centre.x + "," + res_hole.samples[k].centre.y + ") weight=" + res_hole.samples[k].weight);
 
                        if (res_hole != null)
                        {
                            res_hole.Dispose();
                            res_hole = null;
                        }
                    }
                    if (img != null)
                    {
                        img.Dispose();
                        img = null;
                    }
                    if (roi != null)
                    {
                        roi.Dispose();
                        roi = null;
                    }
                    if (res_slice != null)
                    {
                        res_slice.Dispose();
                        res_slice = null;
                    }
                }
            }
 
        FnExit:
 
            if (slice != null)
                slice.Dispose();
            if (hole != null)
                hole.Dispose();
            if (img != null)
                img.Dispose();
            if (roi != null)
                roi.Dispose();
            if (res_slice != null)
                res_slice.Dispose();
            if (res_hole != null)
                res_hole.Dispose();
 
            Console.WriteLine("Release SqueezeBrains library");
            Sb.Release();
 
            Console.WriteLine("Press ENTER to terminate");
            Console.ReadKey();
 
            return err;
        }
 
        static void Main(string[] args)
        {
            execute();
        }
    }
}