嘴唇检测算法源码

㈠ 我的嘴巴以前出过意外 嘴唇变厚了 是否还能通过什么方法变薄

病情分析：
这种情况一般需要注意局部清洁卫生，可以正规医院整形外科检查，必要时可以手术治疗
指导意见：
建议饮食清淡加强营养，注意局部清洁卫生，可以正规医院整形外科检查，必要时手术治疗

㈡ AI在识别人类情绪方面存在严重缺陷，如何解决这一问题

随着人工智能被用来做出更多关于我们生活的决定，工程师们已经找到了使其更具情感智慧的方法。这意味AI可以识别人类自然产生的一些情绪，最明显的是，扫描一个人的脸部并知道他们当时的感受。

人工智能的核心诉求是让机器实现对人类的意识、思维的信息过程的模拟，能以人类智能相似的方式作出反应。这就需要从人类的IQ和EQ两个维度对人工智能进行审视，而目前大部分人工智能所从事的研究仅限于倾向IQ方向的模式识别，通过自然语言处理、机器学习、模式识别、物联感知、逻辑推理等技术的综合应用，使机器具备一定的逻辑思维判断能力。但目前，人工智能情绪识别离开人类的干预，对复杂的情感的理解和表达能力，依然面临着困境。

情绪历史学家Thomas Dixon却对此表示非常乐观，他认为对于AI来说，情绪产生的机制可能类似于对大脑提取的众多因素进行加权计算，只要清楚不同文化、不同个体各因素的权重系数，情绪识别的难题也就迎刃而解。

㈢ 用什么方法测试对唇膏、口红过不过敏

嘴唇是比较容易过敏的地方，说实话，最容易的方法是你在嘴上涂一点，看看肿了没，呵呵......
如果你不愿意最有问题被看出来，我建议你在耳后涂一点试一试，耳后是皮肤最嫩的地方，如果红了，就会过敏，就不要用了，呵呵......耳后没问题嘴上就行了......

㈣ 急求用c或c++实现直线检测的hough变换源代码

Hough变换是图像处理中从图像中识别几何形状的基本方法之一。Hough变换的基本原理在于利用点与线的对偶性，将原始图像空间的给定的曲线通过曲线表达形式变为参数空间的一个点。这样就把原始图像中给定曲线的检测问题转化为寻找参数空间中的峰值问题。也即把检测整体特性转化为检测局部特性。比如直线、椭圆、圆、弧线等。

Hough变换的基本思想

设已知一黑白图像上画了一条直线，要求出这条直线所在的位置。我们知道，直线的方程可以用y=k*x+b 来表示，其中k和b是参数，分别是斜率和截距。过某一点(x0,y0)的所有直线的参数都会满足方程y0=kx0+b。即点(x0,y0)确定了一族直线。方程y0=kx0+b在参数k--b平面上是一条直线，(你也可以是方程b=-x0*k+y0对应的直线)。这样，图像x--y平面上的一个前景像素点就对应到参数平面上的一条直线。我们举个例子说明解决前面那个问题的原理。设图像上的直线是y=x, 我们先取上面的三个点：A(0,0), B(1,1), C(22)。可以求出，过A点的直线的参数要满足方程b=0, 过B点的直线的参数要满足方程1=k+b, 过C点的直线的参数要满足方程2=2k+b, 这三个方程就对应着参数平面上的三条直线，而这三条直线会相交于一点(k=1,b=0)。 同理，原图像上直线y=x上的其它点(如(3,3),(4,4)等) 对应参数平面上的直线也会通过点(k=1,b=0)。这个性质就为我们解决问题提供了方法，就是把图像平面上的点对应到参数平面上的线，最后通过统计特性来解决问题。假如图像平面上有两条直线，那么最终在参数平面上就会看到两个峰值点，依此类推。

简而言之，Hough变换思想为：在原始图像坐标系下的一个点对应了参数坐标系中的一条直线，同样参数坐标系的一条直线对应了原始坐标系下的一个点，然后，原始坐标系下呈现直线的所有点，它们的斜率和截距是相同的，所以它们在参数坐标系下对应于同一个点。这样在将原始坐标系下的各个点投影到参数坐标系下之后，看参数坐标系下有没有聚集点，这样的聚集点就对应了原始坐标系下的直线。

首先，初始化一块缓冲区，对应于参数平面，将其所有数据置为0.对于图像上每一前景点，求出参数平面对应的直线，把这直线上的所有点的值都加1。最后，找到参数平面上最大点的位置，这个位置就是原图像上直线的参数。

在实际应用中，y=k*x+b形式的直线方程没有办法表示x=c形式的直线(这时候，直线的斜率为无穷大)。所以实际应用中，是采用参数方程p=x*cos(theta)+y*sin(theta)。这样，图像平面上的一个点就对应到参数p---theta平面上的一条曲线上，其它的还是一样。

Hough变换推广

1、已知半径的圆

其实Hough变换可以检测任意的已知表达形式的曲线，关键是看其参数空间的选择，参数空间的选择可以根据它的表达形式而定。比如圆的表达形式为，所以当检测某一半径的圆的时候，可以选择与原图像空间同样的空间作为参数空间。那么圆图像空间中的一个圆对应了参数空间中的一个点，参数空间中的一个点对应了图像空间中的一个圆，圆图像空间中在同一个圆上的点，它们的参数相同即a，b相同，那么它们在参数空间中的对应的圆就会过同一个点（a，b），所以，将原图像空间中的所有点变换到参数空间后，根据参数空间中点的聚集程度就可以判断出图像空间中有没有近似于圆的图形。如果有的话，这个参数就是圆的参数。

2、未知半径的圆对于圆的半径未知的情况下，可以看作是有三个参数的圆的检测，中心和半径。这个时候原理仍然相同，只是参数空间的维数升高，计算量增大。图像空间中的任意一个点都对应了参数空间中的一簇圆曲线。，其实是一个圆锥型。参数空间中的任意一个点对应了图像空间中的一个圆。

3、椭圆椭圆有5个自由参数，所以它的参数空间是5维的，因此他的计算量非常大，所以提出了许多的改进算法。

图像空间中的在同一个圆，直线，椭圆上的点，每一个点都对应了参数空间中的一个图形，在图像空间中这些点都满足它们的方程这一个条件，所以这些点，每个投影后得到的图像都会经过这个参数空间中的点。也就是在参数空间中它们会相交于一点。所以，当参数空间中的这个相交点的越大的话，那么说明元图像空间中满足这个参数的图形越饱满。越象我们要检测的东西。 Hough变换能够查找任意的曲线，只要你给定它的方程。Hough变换在检验已知形状的目标方面具有受曲线间断影响小和不受图形旋转的影响的优点，即使目标有稍许缺损或污染也能被正确识别。

㈤ 跪求canny边缘检测算子的c源代码

canny算子代码

void CreatGauss(double sigma, double **pdKernel, int *pnWidowSize);

void GaussianSmooth(SIZE sz, LPBYTE pGray, LPBYTE pResult, double sigma);

void Grad(SIZE sz, LPBYTE pGray, int *pGradX, int *pGradY, int *pMag);

void NonmaxSuppress(int *pMag, int *pGradX, int *pGradY, SIZE sz, LPBYTE pNSRst);

void EstimateThreshold(int *pMag, SIZE sz, int *pThrHigh, int *pThrLow, LPBYTE pGray,
double dRatHigh, double dRatLow);

void Hysteresis(int *pMag, SIZE sz, double dRatLow, double dRatHigh, LPBYTE pResult);

void TraceEdge(int y, int x, int nThrLow, LPBYTE pResult, int *pMag, SIZE sz);

void Canny(LPBYTE pGray, SIZE sz, double sigma, double dRatLow,
double dRatHigh, LPBYTE pResult);

#include "afx.h"
#include "math.h"
#include "canny.h"

// 一维高斯分布函数，用于平滑函数中生成的高斯滤波系数
void CreatGauss(double sigma, double **pdKernel, int *pnWidowSize)
{

LONG i;

//数组中心点
int nCenter;

//数组中一点到中心点距离
double dDis;

//中间变量
double dValue;
double dSum;
dSum = 0;

// [-3*sigma,3*sigma] 以内数据，会覆盖绝大部分滤波系数
*pnWidowSize = 1+ 2*ceil(3*sigma);

nCenter = (*pnWidowSize)/2;

*pdKernel = new double[*pnWidowSize];

//生成高斯数据
for(i=0;i<(*pnWidowSize);i++)
{
dDis = double(i - nCenter);
dValue = exp(-(1/2)*dDis*dDis/(sigma*sigma))/(sqrt(2*3.1415926)*sigma);
(*pdKernel)[i] = dValue;
dSum+=dValue;

}
//归一化
for(i=0;i<(*pnWidowSize);i++)
{
(*pdKernel)[i]/=dSum;
}

}

//用高斯滤波器平滑原图像
void GaussianSmooth(SIZE sz, LPBYTE pGray, LPBYTE pResult, double sigma)
{
LONG x, y;
LONG i;

//高斯滤波器长度
int nWindowSize;

//窗口长度
int nLen;

//一维高斯滤波器
double *pdKernel;

//高斯系数与图像数据的点乘
double dDotMul;

//滤波系数总和
double dWeightSum;

double *pdTemp;
pdTemp = new double[sz.cx*sz.cy];

//产生一维高斯数据
CreatGauss(sigma, &pdKernel, &nWindowSize);

nLen = nWindowSize/2;

//x方向滤波
for(y=0;y<sz.cy;y++)
{
for(x=0;x<sz.cx;x++)
{
dDotMul = 0;
dWeightSum = 0;
for(i=(-nLen);i<=nLen;i++)
{
//判断是否在图像内部
if((i+x)>=0 && (i+x)<sz.cx)
{
dDotMul+=(double)pGray[y*sz.cx+(i+x)] * pdKernel[nLen+i];
dWeightSum += pdKernel[nLen+i];
}
}
pdTemp[y*sz.cx+x] = dDotMul/dWeightSum;
}
}

//y方向滤波
for(x=0; x<sz.cx;x++)
{
for(y=0; y<sz.cy; y++)
{
dDotMul = 0;
dWeightSum = 0;
for(i=(-nLen);i<=nLen;i++)
{
if((i+y)>=0 && (i+y)< sz.cy)
{
dDotMul += (double)pdTemp[(y+i)*sz.cx+x]*pdKernel[nLen+i];
dWeightSum += pdKernel[nLen+i];
}
}
pResult[y*sz.cx+x] = (unsigned char)dDotMul/dWeightSum;
}
}

delete []pdKernel;
pdKernel = NULL;

delete []pdTemp;
pdTemp = NULL;

}

// 方向导数,求梯度
void Grad(SIZE sz, LPBYTE pGray,int *pGradX, int *pGradY, int *pMag)
{
LONG y,x;

//x方向的方向导数
for(y=1;y<sz.cy-1;y++)
{
for(x=1;x<sz.cx-1;x++)
{
pGradX[y*sz.cx +x] = (int)( pGray[y*sz.cx+x+1]-pGray[y*sz.cx+ x-1] );
}
}

//y方向方向导数
for(x=1;x<sz.cx-1;x++)
{
for(y=1;y<sz.cy-1;y++)
{
pGradY[y*sz.cx +x] = (int)(pGray[(y+1)*sz.cx +x] - pGray[(y-1)*sz.cx +x]);
}
}

//求梯度

//中间变量
double dSqt1;
double dSqt2;

for(y=0; y<sz.cy; y++)
{
for(x=0; x<sz.cx; x++)
{
//二阶范数求梯度
dSqt1 = pGradX[y*sz.cx + x]*pGradX[y*sz.cx + x];
dSqt2 = pGradY[y*sz.cx + x]*pGradY[y*sz.cx + x];
pMag[y*sz.cx+x] = (int)(sqrt(dSqt1+dSqt2)+0.5);
}
}
}

//非最大抑制
void NonmaxSuppress(int *pMag, int *pGradX, int *pGradY, SIZE sz, LPBYTE pNSRst)
{
LONG y,x;
int nPos;

//梯度分量
int gx;
int gy;

//中间变量
int g1,g2,g3,g4;
double weight;
double dTmp,dTmp1,dTmp2;

//设置图像边缘为不可能的分界点
for(x=0;x<sz.cx;x++)
{
pNSRst[x] = 0;
pNSRst[(sz.cy-1)*sz.cx+x] = 0;

}
for(y=0;y<sz.cy;y++)
{
pNSRst[y*sz.cx] = 0;
pNSRst[y*sz.cx + sz.cx-1] = 0;
}

for(y=1;y<sz.cy-1;y++)
{
for(x=1;x<sz.cx-1;x++)
{
//当前点
nPos = y*sz.cx + x;

//如果当前像素梯度幅度为0，则不是边界点
if(pMag[nPos] == 0)
{
pNSRst[nPos] = 0;
}
else
{
//当前点的梯度幅度
dTmp = pMag[nPos];

//x,y方向导数
gx = pGradX[nPos];
gy = pGradY[nPos];

//如果方向导数y分量比x分量大，说明导数方向趋向于y分量
if(abs(gy) > abs(gx))
{
//计算插值比例
weight = fabs(gx)/fabs(gy);

g2 = pMag[nPos-sz.cx];
g4 = pMag[nPos+sz.cx];

//如果x,y两个方向导数的符号相同
//C 为当前像素，与g1-g4 的位置关系为：
//g1 g2
// C
// g4 g3
if(gx*gy>0)
{
g1 = pMag[nPos-sz.cx-1];
g3 = pMag[nPos+sz.cx+1];
}

//如果x,y两个方向的方向导数方向相反
//C是当前像素，与g1-g4的关系为：
// g2 g1
// C
// g3 g4
else
{
g1 = pMag[nPos-sz.cx+1];
g3 = pMag[nPos+sz.cx-1];
}
}

//如果方向导数x分量比y分量大，说明导数的方向趋向于x分量
else
{
//插值比例
weight = fabs(gy)/fabs(gx);

g2 = pMag[nPos+1];
g4 = pMag[nPos-1];

//如果x,y两个方向的方向导数符号相同
//当前像素C与 g1-g4的关系为
// g3
// g4 C g2
// g1
if(gx * gy > 0)
{
g1 = pMag[nPos+sz.cx+1];
g3 = pMag[nPos-sz.cx-1];
}

//如果x,y两个方向导数的方向相反
// C与g1-g4的关系为
// g1
// g4 C g2
// g3
else
{
g1 = pMag[nPos-sz.cx+1];
g3 = pMag[nPos+sz.cx-1];
}
}

//利用 g1-g4 对梯度进行插值
{
dTmp1 = weight*g1 + (1-weight)*g2;
dTmp2 = weight*g3 + (1-weight)*g4;

//当前像素的梯度是局部的最大值
//该点可能是边界点
if(dTmp>=dTmp1 && dTmp>=dTmp2)
{
pNSRst[nPos] = 128;
}
else
{
//不可能是边界点
pNSRst[nPos] = 0;
}
}
}
}
}
}

// 统计pMag的直方图，判定阈值
void EstimateThreshold(int *pMag, SIZE sz, int *pThrHigh, int *pThrLow, LPBYTE pGray,
double dRatHigh, double dRatLow)
{
LONG y,x,k;

//该数组的大小和梯度值的范围有关，如果采用本程序的算法
//那么梯度的范围不会超过pow(2,10)
int nHist[256];

//可能边界数
int nEdgeNum;

//最大梯度数
int nMaxMag;

int nHighCount;

nMaxMag = 0;

//初始化
for(k=0;k<256;k++)
{
nHist[k] = 0;
}
//统计直方图,利用直方图计算阈值
for(y=0;y<sz.cy;y++)
{
for(x=0;x<sz.cx;x++)
{
if(pGray[y*sz.cx+x]==128)
{
nHist[pMag[y*sz.cx+x]]++;
}
}
}

nEdgeNum = nHist[0];
nMaxMag = 0;

//统计经过“非最大值抑制”后有多少像素
for(k=1;k<256;k++)
{
if(nHist[k] != 0)
{
nMaxMag = k;
}

//梯度为0的点是不可能为边界点的
//经过non-maximum suppression后有多少像素
nEdgeNum += nHist[k];

}

//梯度比高阈值*pThrHigh 小的像素点总书目
nHighCount = (int)(dRatHigh * nEdgeNum + 0.5);

k=1;
nEdgeNum = nHist[1];

//计算高阈值
while((k<(nMaxMag-1)) && (nEdgeNum < nHighCount))
{
k++;
nEdgeNum += nHist[k];
}

*pThrHigh = k;

//低阈值
*pThrLow = (int)((*pThrHigh) * dRatLow + 0.5);

}

//利用函数寻找边界起点
void Hysteresis(int *pMag, SIZE sz, double dRatLow, double dRatHigh, LPBYTE pResult)
{
LONG y,x;

int nThrHigh,nThrLow;

int nPos;
//估计TraceEdge 函数需要的低阈值，以及Hysteresis函数使用的高阈值
EstimateThreshold(pMag, sz,&nThrHigh,&nThrLow,pResult,dRatHigh,dRatLow);

//寻找大于dThrHigh的点，这些点用来当作边界点，
//然后用TraceEdge函数跟踪该点对应的边界
for(y=0;y<sz.cy;y++)
{
for(x=0;x<sz.cx;x++)
{
nPos = y*sz.cx + x;

//如果该像素是可能的边界点，并且梯度大于高阈值，
//该像素作为一个边界的起点
if((pResult[nPos]==128) && (pMag[nPos] >= nThrHigh))
{
//设置该点为边界点
pResult[nPos] = 255;
TraceEdge(y,x,nThrLow,pResult,pMag,sz);
}

}
}

//其他点已经不可能为边界点
for(y=0;y<sz.cy;y++)
{
for(x=0;x<sz.cx;x++)
{
nPos = y*sz.cx + x;

if(pResult[nPos] != 255)
{
pResult[nPos] = 0;
}
}
}
}

//根据Hysteresis 执行的结果，从一个像素点开始搜索，搜索以该像素点为边界起点的一条边界的
//一条边界的所有边界点，函数采用了递归算法
// 从（x,y)坐标出发，进行边界点的跟踪，跟踪只考虑pResult中没有处理并且可能是边界
// 点的像素（=128），像素值为0表明该点不可能是边界点，像素值为255表明该点已经是边界点

void TraceEdge(int y, int x, int nThrLow, LPBYTE pResult, int *pMag, SIZE sz)
{
//对8邻域像素进行查询
int xNum[8] = {1,1,0,-1,-1,-1,0,1};
int yNum[8] = {0,1,1,1,0,-1,-1,-1};

LONG yy,xx,k;

for(k=0;k<8;k++)
{
yy = y+yNum[k];
xx = x+xNum[k];

if(pResult[yy*sz.cx+xx]==128 && pMag[yy*sz.cx+xx]>=nThrLow )
{
//该点设为边界点
pResult[yy*sz.cx+xx] = 255;

//以该点为中心再进行跟踪
TraceEdge(yy,xx,nThrLow,pResult,pMag,sz);
}
}
}

// Canny算子
void Canny(LPBYTE pGray, SIZE sz, double sigma, double dRatLow,
double dRatHigh, LPBYTE pResult)
{
//经过高斯滤波后的图像
LPBYTE pGaussSmooth;

pGaussSmooth = new unsigned char[sz.cx*sz.cy];

//x方向导数的指针
int *pGradX;
pGradX = new int[sz.cx*sz.cy];

//y方向
int *pGradY;
pGradY = new int[sz.cx*sz.cy];

//梯度的幅度
int *pGradMag;
pGradMag = new int[sz.cx*sz.cy];

//对原图高斯滤波
GaussianSmooth(sz,pGray,pGaussSmooth,sigma);

//计算方向导数和梯度的幅度
Grad(sz,pGaussSmooth,pGradX,pGradY,pGradMag);

//应用非最大抑制
NonmaxSuppress(pGradMag,pGradX,pGradY,sz,pResult);

//应用Hysteresis，找到所有边界
Hysteresis(pGradMag,sz,dRatLow,dRatHigh,pResult);

delete[] pGradX;
pGradX = NULL;
delete[] pGradY;
pGradY = NULL;
delete[] pGradMag;
pGradMag = NULL;
delete[] pGaussSmooth;
pGaussSmooth = NULL;

}

/*
void CChildWnd::OnCanny()
{
if (! m_fOpenFile)
{
return;
}
m_fDone = TRUE;
RGBToGray(szImg, aRGB, aGray, BPP);
Canny(aGray,szImg,0.1,0.9,0.76,aBinImg);

ShowGrayImage("l",szImg,aBinImg);
}
//*/

㈥ 据说看嘴唇颜色能看出身体状况，怎么看的

一、嘴唇为红色,深红色或者紫红色
这种颜色的人可能经常会感觉自己火气很大,如伴口臭、呃逆,说明脾胃湿热;伴两胁胀痛、厌食,说明肝火太旺。常见的不适应有：牙疼、头疼、头晕、便秘、尿黄等
防治方法：
1 减少辛辣食物,糖类,鸡肉等食物的摄入量,这些食物会产生更多的能量,让体内的火气更旺盛。
2 不要服务还有人参和大枣的补品,如果感觉有时特别不舒服时,可以玄参30g生地30g麦冬30g肉桂2g,水煎服。这是古代的名方增液汤,可以明显改善以上不好的症状。

二、嘴唇为淡白色
嘴唇长期发白的应该去医院检查下,以便排除有无贫血的问题。另外有些脾胃虚寒、消化不良的病人也可以表现出口唇缺少红润、干燥等症状,有些还可伴有四肢发冷。常见不适：乏力、困倦、背痛、性欲低下等。
治疗方法：
1 增加营养物质的摄入,不挑食不打算减肥,多吃一些鱼肉、鸡肉、牛肉、羊肉、鸡蛋等。
2 每天服用一些带红色内皮的花生,不限量。
3 不要经常熬夜或者过度熬夜,那样会增加本来已经不足的能源的消耗。

三、嘴唇为青黑（紫）色
如果嘴唇长期出现青紫,预示着你的心脏可能存在问题。长期这样应该去医院检查。某些呼吸系统的疾病也可出现口唇缺少光泽、不够红润的变化。常见不适：胸闷、爱叹气、胸部偶有刺痛、恶梦等。
防治方法：
1 每天坚持运动,每天做有氧运动至少30分钟,可以快走或慢跑。
2 建议每天饮用1-2汤匙的山西老陈醋。老陈醋除了本身的作用外,还有活血化瘀和改善心情的作用。适量的饮用,绝对可以让你青黑色的唇在一段时间之后发生改变。
3 如果有吸烟情况,还是要减少或者戒掉为好。

四、嘴唇周围的皮肤泛起一圈黑色
乳沟嘴唇上有块块黑斑,应及时去医院口腔科检查,排除色素性疾病或血管性疾病的可能。如嘴唇颜色暗淡且发黑,还要检查下消化系统是否存在问题。常见不适：食欲下降、消化较差、下肢沉重感、小便频多。
防治方法：
1 尽量避免各种甜食、油炸、油腻、比较粘的食品、生冷食品等,因为他们能够让你身体里更湿。
2 饭后可以稍微活动下,可以出去散散步,这样会排除体内的一部分湿气。
3 每天试着用热水泡脚,可以把热量从脚步补充到脏器部。

㈦ 嘴唇整形有哪几种方法

1、注射/手术丰唇：如果是天生或者衰老导致嘴唇过于单薄的求美者，可以通过注射填充物或人工真皮植入唇部等方法改善，在根据实际情况设计方案手术后能让嘴唇变得性感和丰满。

2、唇弓整形术：如果属于唇弓不明显、唇弓及唇形逐渐变薄的求美者，可以采用的改善方法就是唇弓整形术。但这项手术的缺点是红唇的上方恢复后可能会出现一条非常明显的疤痕。

3、唇珠再造术：有些求美者非常想拥有一个完美的唇珠，就可以考虑进行唇珠整形术，可采用的手术方法包括了从唇内缘设计作出一个唇珠，也可以在局部注射玻尿酸或者脂肪等填充物来达到唇珠再造的目的。

4、嘴唇修薄术：如明显的嘴唇外翻或嘴唇过厚的求美者，可以进行嘴唇修薄术治疗，手术时把过多的唇黏膜加以切除，或者连同口轮肌一并修除，最后把红唇向内翻转同时进行缝合即成。

(7)嘴唇检测算法源码扩展阅读

唇部整形的危害

1.唇部整形后出现炎症反应

很多手术后都会出现炎症感染的情况，这种情况多数是由于手术操作不当引发医源性感染或者是由于术后护理不正确而出现的炎症后遗症，需要在医生指导下使用药物消炎。

2.唇部整形后出现淤血

如果唇部整形手术失败的话，会对患者的唇部造成伤害，从而出现淤血的情况，不利于恢复嘴唇的正常形态，此时需要进行复查，如果淤血严重或者还有其他并发症的话可能需要再次手术修复。

3.唇部整形手术效果不理想

一般整形的正常流程都是先接受整形部位的检查，然后结合黄金比例及整体面容特征进行设计，这样才能获得更加理想的整形效果，如果效果不理想的话，最好是接受整形修复手术。

唇部整形后遗症的预防

1.提前三天口服板蓝根冲剂或消炎药，漂唇后爱美者及时生理盐水漱口。

2.选择在唇整形操作过程严格消毒的正规机构来做手术，因为严格消毒控制了致病细菌的总量，因此严格杀菌消毒是预防唇整形后遗症的必要手段。

3.在唇整形后的创口未完全恢复之前不适宜化妆，因为化妆品中的化学成分容易对创口造成伤害，引发后遗症。

4.保持创口清洁干燥，尽量少做一些大动作的唇部运动，不可随便用手或其他物品触碰唇部，以免漂唇的创口裂开受细菌感染而引起后遗症。

㈧ 谁有基于opencv的人脸检测源码啊发给给我看看啊

openCV自带的例子有facedetect文件，这就是源码，是基于adaboost算法训练的级联分类器，并进行了检测。这个例子比较复杂，还可以用SVM，模板等方法实现人脸检测，但是，目前看来，效果最好的就是adaboost 了。希望对你有所帮助。

㈨ 基于计算机视觉的行人检测及跟踪算法设计 采用opencv和vc用camshift算法。实习急用，只要源代码

这个实现的难度不是非常大，但是编代码需要耗点时间，你可以知道些人脸检测的代码，改改就是了，人脸的分类器和人全身的分类器opencv都是自带的

㈩ 设计一个算法,检验C源码中的括号对是否正确配对.要求在某个C源程序文件上对该算法

#include"stdio.h"
#include"string.h"
#include"stdlib.h"
#define YES 1
#define NO 0
#define result int

result matchsuccess(char *init_str)
{
int i=0;
int j=0;
int countv=0;/* 用来确定左括号和右括号数相差值 初始为相等 */
int countn=0;/* 初始化式子的总括号数为0 */
int len=strlen(init_str);
char *onlypar;

/* 计算括号数 */
for(i=0;i<len;i++)
{
if(init_str[i]=='{'||
init_str[i]=='}'||
init_str[i]=='['||
init_str[i]==']'||
init_str[i]=='('||
init_str[i]==')')
countn++;
}
/* 给只有括号的数组分配空间 */
onlypar=(char *)malloc(countn*sizeof(char));
/* 初始化只有括号的数组 */
for(i=0,j=0;j<countn;i++)
{
if(init_str[i]=='{'||
init_str[i]=='}'||
init_str[i]=='['||
init_str[i]==']'||
init_str[i]=='('||
init_str[i]==')')
onlypar[j++]=init_str[i];
}
/* 出现只有两个括号的情况，判断是不是一对就可以了 */
if(countn==2)
{
if((onlypar[0]-onlypar[1]==1)||
(onlypar[0]-onlypar[1]==2) )
{
free(onlypar);
return YES;
}
}
/* 判断左括号是不是等于右括号 */
/* 是左括号 countv++ 是右括号 countv--*/
/* 如果左括号数和右括号数量相等 count=0 */
for(i=0;i<countn;i++)
{
switch(onlypar[i])
{
case '{':countv++;continue;
case '[':countv++;continue;
case '(':countv++;continue;
case ')':countv--;continue;
case ']':countv--;continue;
case '}':countv--;continue;
default:continue;
}
/* count>=0是恒成立的，因为成对的括 */
/* 弧里左括号总是出现在右括号的前面 */
if( countv<0 )
{
free(onlypar);
return NO;
}
}
/* 右括号多时count>0 */
if(countv>0)
{
free(onlypar);
return NO;
}
/* '{'=123 '}'=125 '['=91 */
/* ']'=93 '('=40 ')'=41 */
/* '{'-'}'=-2 '['-']'=-2 '('-')'=-1 */
/*最有一种情况，举个典型的例子说明： "{[([)]]}" */
/*其愿意是"{[[()]]}",通过观察可以知道：若一对括号之间 */
/*如果两括号之间只间隔了一个和他们不属于同意级别的括号 */
/*那么结果不匹配 */

for(i=0; countn>2&& i<countn-2;i++)
{
if( ((onlypar[i]-onlypar[i+2]==-2)&&(onlypar[i] != onlypar[i+1])) ||
((onlypar[i]-onlypar[i+2]==-1)&&(onlypar[i] != onlypar[i+1])) )

{
free(onlypar);
return NO;
}
}
free(onlypar);
return YES;//排除了各种可能情况 返回YES
}

int main(int argc,char *argv[])
{
char init_str[100];
printf("input: ");
gets(init_str);
if(matchsuccess(init_str)==YES)
printf("match success\n");
else
printf("match fault \n");
return 1;
}