Halide与opencv混编

WiTiAi

Halide与opencv混编：
【1】C#代码

1. // See https://aka.ms/new-console-template for more information
   
2. using OpenCvSharp;
   
3. using System.Runtime.InteropServices;
   
4. using ConsoleApp1;
   
5. using System;
   
6. 
   
7. void printhello()
   
8. {
   
9.     Console.WriteLine("Hello, World!");
   
10. }
    
11. printhello();
    
12. int a = 42;
    
13. int b = 119;
    
14. int c = a + b;
    
15. Console.WriteLine(c);
    
16. 
    
17. string imagepath = @"C:\\AIOCRProjects\\Image\\1 (1).jpg";
    
18. Mat src = Cv2.ImRead(imagepath, ImreadModes.Grayscale);
    
19. // 获取灰度图像的宽度、高度和每像素的字节数  
    
20. int width = src.Cols;
    
21. int height = src.Rows;
    
22. int bytesPerPixel = src.ElemSize1();
    
23. 
    
24. // 计算图像数据的总字节大小  
    
25. CallAIDLL.BlurHal2_test(src.Width, src.Height, src.Channels(), src.Data);
    
26. // 锁定Mat对象以获取其数据指针
    
27. Console.WriteLine(src.Channels());
    
28. Console.WriteLine("done");
    
29. 
    
30. Mat ColorMat = Cv2.ImRead(imagepath, ImreadModes.Color);
    
31. var bytes = new byte[ColorMat.Total() * 3];//这里必须乘以通道数，不然数组越界，也可以用w*h*c，差不多
    
32. //var bytes = new byte[ColorMat.Width * ColorMat.Height * ColorMat.Channels()];//这里必须乘以通道数，不然数组越界，也可以用w*h*c，差不多
    
33. //Console.WriteLine(ColorMat.Total() * 3);
    
34. //Console.WriteLine(ColorMat.Width * ColorMat.Height * ColorMat.Channels());
    
35. Marshal.Copy(ColorMat.Data, bytes, 0, bytes.Length);
    
36. IntPtr p0 = Marshal.AllocHGlobal(ColorMat.Width * ColorMat.Height * ColorMat.Channels());
    
37. Marshal.Copy(bytes, 0, p0, ColorMat.Width * ColorMat.Height * ColorMat.Channels());
    
38. Console.WriteLine(ColorMat.Channels());
    
39. Console.WriteLine(ColorMat.Width);
    
40. Console.WriteLine(ColorMat.Height);
    
41. CallAIDLL.BlurHal2_test(ColorMat.Width, ColorMat.Height, ColorMat.Channels(), p0);
    
42. 
    
43. Console.ReadKey();

复制代码

【2】C++代码：

1. Halide::Func AIpredict::BlurWiti3(Halide::Param<int32_t> aWidth, Halide::Param<int32_t> aHeight, Halide::Param<int32_t> aChannel, Halide::ImageParam input)
   
2. {
   
3.         //Mat inputMat = Intptr2Mat(aWidth, aHeight, aChannel, aBytes); // 灰度图像
   
4.         //Halide::Buffer<uint8_t> input = Mat2Buffer(inputMat);         // GrayImage
   
5.         Halide::Var x, y, c;
   
6.         Halide::Func clamped;
   
7.         Halide::Expr clamped_x = Halide::clamp(x, 0, input.width() - 1);
   
8.         Halide::Expr clamped_y = Halide::clamp(y, 0, input.height() - 1);
   
9.         //std::cout << "image cols: " << input.dimensions() << std::endl;
   
10.         //if (aChannel.get() == 3)
    
11.         //{
    
12.                 input.dim(0).set_stride(3);     // stride in dimension 0 (x) is three
    
13.                 input.dim(2).set_stride(1);     // stride in dimension 2 (c) is one
    
14.                 input.dim(2).set_bounds(0, 3);  // Dimension 2 (c) starts at 0 and has extent 3.
    
15.         //}
    
16.         clamped(x, y, c) = input(clamped_x, clamped_y, c);
    
17.         Halide::Func input_16;
    
18.         input_16(x, y, c) = cast<uint16_t>(clamped(x, y, c));
    
19.         Halide::Func blur_x;
    
20.         blur_x(x, y, c) = (input_16(x - 1, y, c) + 2 * input_16(x, y, c) + input_16(x + 1, y, c)) / 4;
    
21.         Halide::Func blur_y;
    
22.         blur_y(x, y, c) = (blur_x(x, y - 1, c) + 2 * blur_x(x, y, c) + blur_x(x, y + 1, c)) / 4;
    
23.         //Buffer<uint8_t> result = output.realize({ input.width(), input.height() });  // GrayImage
    
24.         //Mat output_image_last = Buffer2Mat(result);
    
25.         //return (Mat2UnsignedChar(output_image_last));
    
26. 
    
27.         // Schedule
    
28.         //blur_x.compute_root().vectorize(x, 8).parallel(y);
    
29.         //blur_y.compute_at(blur_x, y).vectorize(x, 8);
    
30. 
    
31.         Halide::Func output;
    
32.         output(x, y, c) = cast<uint8_t>(blur_y(x, y, c));
    
33. 
    
34.         output.compile_jit();
    
35.         return output;
    
36. }
    
37. Halide::Func AIpredict::BlurWiti2(Halide::Param<int32_t> aWidth, Halide::Param<int32_t> aHeight, Halide::Param<int32_t> aChannel, Halide::ImageParam input)
    
38. {
    
39.         //Mat inputMat = Intptr2Mat(aWidth, aHeight, aChannel, aBytes); // 灰度图像
    
40.         //Halide::Buffer<uint8_t> input = Mat2Buffer(inputMat);         // GrayImage
    
41.         Halide::Var x, y, c;
    
42.         Halide::Func clamped;
    
43.         Halide::Expr clamped_x = Halide::clamp(x, 0, input.width() - 1);
    
44.         Halide::Expr clamped_y = Halide::clamp(y, 0, input.height() - 1);
    
45.         //std::cout << "image cols: " << input.dimensions() << std::endl;
    
46.         //if (aChannel.get() == 3)
    
47.         //{
    
48.         //input.dim(0).set_stride(3);     // stride in dimension 0 (x) is three
    
49.         //input.dim(2).set_stride(1);     // stride in dimension 2 (c) is one
    
50.         //input.dim(2).set_bounds(0, 3);  // Dimension 2 (c) starts at 0 and has extent 3.
    
51.         //}
    
52.         clamped(x, y, c) = input(clamped_x, clamped_y, c);
    
53.         Halide::Func input_16;
    
54.         input_16(x, y, c) = cast<uint16_t>(clamped(x, y, c));
    
55.         Halide::Func blur_x;
    
56.         blur_x(x, y, c) = (input_16(x - 1, y, c) + 2 * input_16(x, y, c) + input_16(x + 1, y, c)) / 4;
    
57.         Halide::Func blur_y;
    
58.         blur_y(x, y, c) = (blur_x(x, y - 1, c) + 2 * blur_x(x, y, c) + blur_x(x, y + 1, c)) / 4;
    
59.         //Buffer<uint8_t> result = output.realize({ input.width(), input.height() });  // GrayImage
    
60.         //Mat output_image_last = Buffer2Mat(result);
    
61.         //return (Mat2UnsignedChar(output_image_last));
    
62. 
    
63.         // Schedule
    
64.         //blur_x.compute_root().vectorize(x, 8).parallel(y);
    
65.         //blur_y.compute_at(blur_x, y).vectorize(x, 8);
    
66. 
    
67.         Halide::Func output;
    
68.         output(x, y, c) = cast<uint8_t>(blur_y(x, y, c));
    
69. 
    
70.         output.compile_jit();
    
71.         return output;
    
72. }
    
73. 
    
74. void AIpredict::BlurHal2_test(int aWidth, int aHeight, int aChannel, unsigned char* aBytes)
    
75. {
    
76.         //cv::Mat inputMat2;
    
77.         //inputMat2 = inputMat.clone();
    
78.         Halide::Param<int32_t> WidthHal;
    
79.         Halide::Param<int32_t> HeightHal;
    
80.         Halide::Param<int32_t> ChannelHal;
    
81.         Halide::ImageParam GrayHal(type_of<uint8_t>(), 3);  // third channel = 1
    
82.         //Halide::ImageParam RGBHal(type_of<uint8_t>(), 3); // third channel = 3
    
83.         if (aChannel == 1)
    
84.         {
    
85.                 BlurWiti_Pipeline = BlurWiti2(WidthHal, HeightHal, ChannelHal, GrayHal);
    
86.         }
    
87.         else
    
88.         {
    
89.                 BlurWiti_Pipeline = BlurWiti3(WidthHal, HeightHal, ChannelHal, GrayHal);
    
90.         }
    
91. 
    
92.         cv::Mat inputMat;
    
93.         inputMat = Intptr2Mat(aWidth, aHeight, aChannel, aBytes);
    
94.         /*std::cout << "image channel: " << inputMat.channels() << std::endl;
    
95.         std::cout << "image dims: " << inputMat.dims << std::endl;
    
96.         cv::imwrite("D:\\230.jpg", inputMat);
    
97.         cv::Mat inputMat2;
    
98.         inputMat2 = cv::imread("C:\\AIOCRProjects\\Image\\1 (1).jpg", 1);
    
99.         std::cout << "image channel: " << inputMat2.channels() << std::endl;
    
100.         std::cout << "image dims: " << inputMat2.dims << std::endl;*/
     
101. 
     
102.         Halide::Buffer<uint8_t> input = Mat2Buffer(inputMat); // GrayImage, default dimension = 3
     
103.         //Halide::Buffer<uint8_t> input = Halide::Runtime::Buffer<uint8_t>::make_interleaved(aBytes, aWidth, aHeight, aChannel);
     
104.         //Halide::Buffer<uint8_t> input2 = load_image("C:\\AIOCRProjects\\Image\\1 (1).jpg"); // GrayImage
     
105.         //std::cout << "image channel: " << input.channels() << std::endl;
     
106.         //std::cout << "image dimensions: " << input.dimensions() << std::endl;
     
107.         //std::cout << "image channel: " << input2.channels() << std::endl;
     
108.         //std::cout << "image dimensions: " << input2.dimensions() << std::endl;
     
109.         //Halide::Buffer<uint8_t> input3 = input(:, : , 0);
     
110.         //Halide::Tools::save_image(input, "D:\\brighter.png");
     
111. 
     
112.         //Halide::Buffer<uint8_t> input = load_image("D:\\brighter.png"); // GrayImage
     
113.         //input = Halide::Tools::load_image("D:\\brighter.png"); // GrayImage
     
114. 
     
115.         WidthHal.set(aWidth);
     
116.         HeightHal.set(aHeight);
     
117.         ChannelHal.set(aChannel);
     
118.         GrayHal.set(input);
     
119. 
     
120.         //std::cout << "image cols: " << input.width() << std::endl;
     
121.         //std::cout << "image rows: " << input.height() << std::endl;
     
122.         //std::cout << "image channel: " << input.channels() << std::endl;
     
123. 
     
124.         Halide::Buffer<uint8_t> output(aWidth, aHeight, aChannel);
     
125.         BlurWiti_Pipeline.realize(output);
     
126. 
     
127.         cv::Mat outImage = Buffer2Mat(output);
     
128.         cv::imwrite("D:\\23.jpg", outImage);
     
129.         //return Buffer2Mat(output);
     
130. }
     

复制代码