嘴唇檢測演算法源碼

㈠ 我的嘴巴以前出過意外 嘴唇變厚了 是否還能通過什麼方法變薄

病情分析：
這種情況一般需要注意局部清潔衛生，可以正規醫院整形外科檢查，必要時可以手術治療
指導意見：
建議飲食清淡加強營養，注意局部清潔衛生，可以正規醫院整形外科檢查，必要時手術治療

㈡ 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;
}