C#界面
可执行程序
视频演示
笔记：
一、C#调用Python脚本程序
用到了控件ConsoleControl。
corePath = "./core.py";//python脚本
corePathExe = "core.exe"; //python生成的可执行文件
private void startBtn_Click(object sender, EventArgs e)
{
switch (File.Exists(corePathExe))//python可执行文件存在？
{
case true://存在
if (!File.Exists(corePathExe)) return;
appConsole.StartProcess("cmd", $"/c {corePathExe}");//ConsoleControl 控件 启动python进程： "core.exe"
break;
case !false:
if (!File.Exists(corePath)) return;
appConsole.StartProcess("cmd", $"/c @python {corePath}");//启动python脚本："./core.py"
break;
default:
break;
}
/*
ProcessStartInfo startInfo = new ProcessStartInfo();
startInfo.FileName = "python";
startInfo.Arguments = corePath;
startInfo.UseShellExecute = true;
Process.Start(startInfo);
*/
menuCtrl.SelectedIndex = 1;//设置Tab控件 活动页面
if (closeCheck.Checked) this.WindowState = FormWindowState.Minimized;//勾选复选框，最小化窗体
}二、Python脚本：对象尺寸检测
2.1 core.py
import cv2
import helper
import json
img_f = open('./settings.json') #读取配置
settings = json.load(img_f) #加载配置参数
webcam = settings['useWebcam'] #是否使用网络摄像头
path = settings['imgFilePath'] #图片路径
cap = cv2.VideoCapture(int(settings['webcamIndex']))#打开摄像头
dashed_gap = int(settings['dashGapScale']) #虚线 破折号间距
cap.set(10, 160) #https://blog.csdn.net/qq_43797817/article/details/108096827 10:CV_CAP_PROP_BRIGHTNESS 图像的亮度（仅适用于相机）
resArray = settings['resolution'].split('x') #分辨率
#print(int(resArray[0]), int(resArray[1]))
cap.set(3, int(resArray[0])) #3:CV_CAP_PROP_FRAME_WIDTH 视频流中帧的宽度。
cap.set(4, int(resArray[1])) #4:CV_CAP_PROP_FRAME_HEIGHT 视频流中帧的高度
scale = int(settings['generalScale']) #比例：图像像素 与 CM 的比例
wP = 210 * scale #210*3=630
hP = 297 * scale #297*3=891
windowName = settings['windowName'] #窗口标题
print('Settings loaded.') #
checkPrintLoop = False #图像处理轮询未开始
while True:
if checkPrintLoop == False:
print('Image process loop started.')
checkPrintLoop = True
if webcam:#使用网络摄像头
success, img = cap.read() #读取一帧
imgLast = img #获取最新的一帧
else:
img = cv2.imread(path) #读取一帧图像
imgContours, conts = helper.getBorders(img, minArea=50000, filter=4) #获取四边形边界框
if len(conts) != 0: #找到对象
biggest = conts[0][2] #拟合的四边形
# print(biggest)
imgWarp = helper.warpImg(img, biggest, wP, hP) #投影映射并缩放图像 把图像缩放为WP,hP尺寸
imgContours2, conts2 = helper.getBorders(imgWarp, minArea=2000, filter=4, cThr=[50, 50], draw=False) #在从映射为矩形的图像上搜索矩形边界框 面积大于2000，四边形
if len(conts) != 0: #找到边界四边形
for obj in conts2: #遍历找到的边界框数组：从大到小排序
#print(obj[2])
#cv2.polylines(imgContours2, helper.getDashedPoint(obj[2]), True, (0, 140, 255), 2)
#helper.drawpoly(imgContours2, [obj[2]], (0, 140, 255), 2)
nPoints = helper.reorder(obj[2]) #重排序四边形角点
nW = round((helper.findDis(nPoints[0][0]//scale, nPoints[1][0]//scale)/10), 1) #真实宽度尺寸 地板除（取整除） x // y
nH = round((helper.findDis(nPoints[0][0]//scale, nPoints[2][0]//scale)/10), 1) #真实高度
#objDef1 = (nPoints[0][0][0], nPoints[0][0][1]), (nPoints[1][0][0], nPoints[1][0][1]) #
#objDef2 = (nPoints[0][0][0], nPoints[0][0][1]), (nPoints[2][0][0], nPoints[2][0][1]) #
#print(obj[2][0][0], obj[2][1][0])
#绘制四边形虚线直线 图像，起点，终点，颜色，线宽，默认点类型，破折号间距
helper.dashLine(imgContours2, obj[2][0][0], obj[2][1][0], (0, 140, 255), 2, 'dotted', dashed_gap)
helper.dashLine(imgContours2, obj[2][1][0], obj[2][2][0], (0, 140, 255), 2, 'dotted', dashed_gap)
helper.dashLine(imgContours2, obj[2][2][0], obj[2][3][0], (0, 140, 255), 2, 'dotted', dashed_gap)
helper.dashLine(imgContours2, obj[2][3][0], obj[2][0][0], (0, 140, 255), 2, 'dotted', dashed_gap)
#helper.dashLine(imgContours2, objDef2[0], objDef2[1], (0, 140, 255), 2)
#cv2.arrowedLine(imgContours2, objDef1[0], objDef1[1], (255, 0, 255), 3, 8, 0, 0.05)
#cv2.arrowedLine(imgContours2, objDef2[0], objDef2[1], (255, 0, 255), 3, 8, 0, 0.05)
x, y, w, h = obj[3] #边界矩形
#print(x, y, w, h)
cv2.putText(imgContours2, '{}cm'.format(nW), (x + 30, y - 10), cv2.QT_FONT_NORMAL, 0.5, (0, 0, 0), 1) #显示 宽度多少cm
cv2.putText(imgContours2, '{}cm'.format(nH), (x - 70, y + h // 2), cv2.QT_FONT_NORMAL, 0.5,(0, 0, 0), 1) #显示高度 多少cm
imgLast = imgContours2 #最终要显示的图像：有尺寸信息
#cv2.imshow('A4', imgContours2)
img = cv2.resize(img, (0, 0), None, 0.5, 0.5) #缩放图像 如果dsize被设置为0（None），则按fx与fy与原始图像大小相乘得到输出图像尺寸大小
cv2.imshow(windowName, imgLast) #显示
k =cv2.waitKey(0) #无限等待按键
if k == 27: break # 键盘上Esc键的键值
if cv2.getWindowProperty(windowName, cv2.WND_PROP_VISIBLE) <= 0:
cv2.destroyAllWindows()
break2.2 helper.py
from operator import index
import cv2
import numpy as np
#图像处理，找到边界框
def getBorders(img,cThr=[100,100],showCanny=False,minArea=1000,filter=0,draw =False):
imgGray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) #灰度图
imgBlur = cv2.GaussianBlur(imgGray,(5,5),1) #高斯滤波
imgCanny = cv2.Canny(imgBlur,cThr[0],cThr[1]) #canny边缘检测， cThr:阈值最小、最大值
kernel = np.ones((5,5)) #卷积核大小
imgDial = cv2.dilate(imgCanny,kernel,iterations=3) #膨胀操作
imgThre = cv2.erode(imgDial,kernel,iterations=2) #腐蚀操作
if showCanny:cv2.imshow('Canny',imgThre) #显示边缘检测结果，默认false，不显示
contours,hiearchy = cv2.findContours(imgThre,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE) #搜索轮廓
finalCountours = []
for i in contours: #遍历搜索结果
area = cv2.contourArea(i) #第i+1轮廓面积 https://www.jianshu.com/p/6bde79df3f9d
if area > minArea: #大于设定的面积阈值
peri = cv2.arcLength(i,True) #计算轮廓的周长
approx = cv2.approxPolyDP(i,0.02*peri,True) #轮廓的多边形拟合
bbox = cv2.boundingRect(approx) #多边形的矩形框 boundingRect、minAreaRect 寻找包裹轮廓的最小正矩形、最小斜矩形 https://www.cnblogs.com/bjxqmy/p/12347355.html
if filter > 0: #根据拟合多边形边数过滤 0：不过滤
if len(approx) == filter:
finalCountours.append([len(approx),area,approx,bbox,i]) #添加到最终边界结果数组
else:
finalCountours.append([len(approx),area,approx,bbox,i]) #边数，面积，近似多边形，边界框，轮廓
finalCountours = sorted(finalCountours,key = lambda x:x[1] ,reverse= True) #reverse = True 降序 ， reverse = False 升序（默认） 最终边界框数组：面积 排序
if draw:
for con in finalCountours:
cv2.drawContours(img,con[4],-1,(0,0,255),3) #绘制红色轮廓，
return img, finalCountours #返回灰度图（可能带有轮廓），最终轮廓数组
#重排序拟合的四边形的4 的点
def reorder(myPoints):
#print(myPoints.shape)
myPointsNew = np.zeros_like(myPoints) #初始化点数组
myPoints = myPoints.reshape((4,2)) #4个点x,y
add = myPoints.sum(1) #array.sum(axis =1),对array的每一行进行相加
myPointsNew[0] = myPoints[np.argmin(add)] #左上角点 https://blog.csdn.net/qq_37591637/article/details/103385174
myPointsNew[3] = myPoints[np.argmax(add)] #右下角点
diff = np.diff(myPoints,axis=1)#y 沿着指定轴计算第N维的离散差值 第一个差异由 out[i]=x[i+1]-a[i]
myPointsNew[1]= myPoints[np.argmin(diff)] #左下角点
myPointsNew[2] = myPoints[np.argmax(diff)] #右上角点
return myPointsNew
#获取排序后索引指定的角点
def getorder(myPoints, index):
#print(myPoints.shape)
myPointsNew = np.zeros_like(myPoints)
myPoints = myPoints.reshape((4,2))
add = myPoints.sum(1)
myPointsNew[0] = myPoints[np.argmin(add)]
myPointsNew[3] = myPoints[np.argmax(add)]
diff = np.diff(myPoints,axis=1)
myPointsNew[1]= myPoints[np.argmin(diff)]
myPointsNew[2] = myPoints[np.argmax(diff)]
return myPointsNew[index]
#压缩图像， 近似四边形投影映射，截取大部分
def warpImg(img,points,w,h,pad=20):
# print(points)
points = reorder(points) #重排序四个角点
pts1 = np.float32(points) #浮点数组：重排序的拟合的图像角点
pts2 = np.float32([[0,0],[w,0],[0,h],[w,h]]) #变换后的图像顶点
matrix = cv2.getPerspectiveTransform(pts1,pts2) #获取投影映射(Projective Mapping) 透视变换(Perspective Transformation)矩阵
imgWarp = cv2.warpPerspective(img,matrix,(w,h)) #投影映射
imgWarp = imgWarp[pad:imgWarp.shape[0]-pad,pad:imgWarp.shape[1]-pad] #去掉pad边界填充
return imgWarp
#计算两点距离
def findDis(pts1,pts2):
return ((pts2[0]-pts1[0])**2 + (pts2[1]-pts1[1])**2)**0.5
#是否能整除
def checkDivide(num, num2):
boolDef = (num % num2) == 0
return (boolDef)
#获取points中指定索引的点
def getPoint(points, _index):
newPoints = []
for _point in points:
newPoints.append(_point)
_lastValue = newPoints[_index]
return _lastValue
#绘制破折线 直线
def dashLine(img,pt1,pt2,color,thickness=1,style='dotted',gap=20):
dist =((pt1[0]-pt2[0])**2+(pt1[1]-pt2[1])**2)**.5
#dist = dist * 3
pts= []
for i in np.arange(0,dist,gap):
r=i/dist
x=int((pt1[0]*(1-r)+pt2[0]*r)+.5)
y=int((pt1[1]*(1-r)+pt2[1]*r)+.5)
p = (x,y)
pts.append(p)
if style=='dotted':
for p in pts:
cv2.circle(img,p,thickness,color,-1)
else:
s=pts[0]
e=pts[0]
i=0
for p in pts:
s=e
e=p
if i%2==1:
cv2.line(img,s,e,color,thickness)
i+=1
#绘制多边形-
def drawpoly(img,pts,color,thickness=1,style='dotted',):
s=pts[0]
e=pts[0]
pts.append(pts.pop(0))
i=0
for p in pts:
if p==e:continue
s=e #起点
if p==p[len(p)-1]:e=pts[0]
e=p #更新end点
dashLine(img,s,e,color,thickness,style)三、json参数C#读写操作
setting.json文件
{"useWebcam":false,"webcamIndex":0,"imgFilePath":"./3.jpg","generalScale":3,"dashGapScale":10,"resolution":"1920x1080","windowName":"Output Window"}json配置类
using System.Text;
using Newtonsoft.Json;
using System.IO;
using System.Collections.Generic;
namespace ObjectMeasurement
{
public class CoreSettings
{
//属性配置类
private class CoreProperties//配置类
{
public bool useWebcam { get; set; }//使用网络摄像头
public int webcamIndex { get; set; }//摄像头索引
public string imgFilePath { get; set; }//图片路径
public int generalScale { get; set; }//比例
public int dashGapScale { get; set; }//
public string resolution { get; set; }//分辨率
public string windowName { get; set; }//窗口标题
}
//私有变量
private bool a_useWebcam { get; set; }
private int a_webcamIndex { get; set; }
private string a_imgFilePath { get; set; }
private int a_generalScale { get; set; }
private int a_dashGapScale { get; set; }
private string a_resolution { get; set; }
private string a_windowName { get; set; }
//公开属性
public bool useWebcam { get; private set; }
public int webcamIndex { get; private set; }
public string imgFilePath { get; private set; }
public int generalScale { get; private set; }
public int dashGapScale { get; private set; }
public string resolution { get; private set; }
public string windowName { get; private set; }
private string jsonPath { get; set; }//序列化字符串
//构造函数1：加载序列化字符串
public CoreSettings(string _jsonPath)
{
jsonPath = _jsonPath;
LoadJson();//加载序列化字符串，反序列化，设置配置
}
//构造函数2： 加载参数
public void Configure(bool _useWebcam, int _webcamIndex,
string _imgFilePath, int _generalScale,
int _dashGapScale, string _resolution, string _windowName)
{
useWebcam = _useWebcam;
webcamIndex = _webcamIndex;
imgFilePath = _imgFilePath;
generalScale = _generalScale;
dashGapScale = _dashGapScale;
resolution = _resolution;
windowName = _windowName;
//
a_useWebcam = _useWebcam;
a_webcamIndex = _webcamIndex;
a_imgFilePath = _imgFilePath;
a_generalScale = _generalScale;
a_dashGapScale = _dashGapScale;
a_resolution = _resolution;
a_windowName = _windowName;
}
//加载json字符串
public void LoadJson()
{
string json = File.ReadAllText(jsonPath);
CoreProperties loadedSettings = JsonConvert.DeserializeObject<CoreProperties>(json);//反序列化
Configure(loadedSettings.useWebcam, loadedSettings.webcamIndex,
loadedSettings.imgFilePath, loadedSettings.generalScale, loadedSettings.dashGapScale,
loadedSettings.resolution, loadedSettings.windowName);//配置
}
//保存序列化对象
public void Save()
{
CoreProperties properties = new CoreProperties
{
useWebcam = a_useWebcam,
webcamIndex = a_webcamIndex,
imgFilePath = a_imgFilePath,
generalScale = a_generalScale,
dashGapScale = a_dashGapScale,
resolution = a_resolution,
windowName = a_windowName
};
string writeJson = JsonConvert.SerializeObject(properties).ToString();//配置类序列化
/*
Dictionary<string, string> replacePairs = new Dictionary<string, string>();
replacePairs.Add("_useWebcam", "useWebcam");
replacePairs.Add("_webcamIndex", "webcamIndex");
replacePairs.Add("_imgFilePath", "imgFilePath");
replacePairs.Add("_generalScale", "generalScale");
replacePairs.Add("_dashGapScale", "dashGapScale");
replacePairs.Add("_resolution", "resolution");
replacePairs.Add("_windowName", "windowName");
replacePairs.Add("_", "");
foreach (KeyValuePair<string, string> item in replacePairs)
{
string key = item.Key;
writeJson.Replace(key.ToString(), item.Value.ToString());
}
*/
// System.Windows.Forms.MessageBox.Show(JsonConvert.SerializeObject(properties));
File.WriteAllText(jsonPath, JsonConvert.SerializeObject(properties));//保存序列化的配置
}
}
}json参数加载和保存
//关闭窗口时，读取参数设置配置
private void SettingsForm_FormClosing(object sender, FormClosingEventArgs e)
{
bool _useWebcam = settings_visualSource.SelectedItem.ToString() == "Web Camera";
int _webcamIndex = Convert.ToInt32(settings_WebcamIndex.Value);
string _imgFilePath = settings_ImageFile.Text.ToString();
int _generalScale = Convert.ToInt32(settings_GeneralScale.Value);
int _dashGapScale = Convert.ToInt32(settings_DashGapScale.Value);
string _resolution = settings_Resolution.Text.ToString();
string _windowName = settings_WindowTitle.Text.ToString();
MainForm.coreSettings.Configure(_useWebcam, _webcamIndex, _imgFilePath, _generalScale, _dashGapScale, _resolution, _windowName);
MainForm.coreSettings.Save();
}
private void SettingsForm_Load(object sender, EventArgs e)
{
CoreSettings core = MainForm.coreSettings;
core.LoadJson();
if (core.useWebcam)
{
settings_visualSource.SelectedIndex = 0;
}
else
{
settings_visualSource.SelectedIndex = 1;
}
settings_WebcamIndex.Value = core.webcamIndex;
settings_ImageFile.Text = core.imgFilePath;
settings_GeneralScale.Value = core.generalScale;
settings_DashGapScale.Value = core.dashGapScale;
settings_Resolution.Text = core.resolution;
settings_WindowTitle.Text = core.windowName;
}参考：
https://blog.csdn.net/u010636181/article/details/80659700