/* Clean up */
static void
gst_face_detect_finalize (GObject * obj)
{
GstFaceDetect *filter = GST_FACE_DETECT (obj);
if (filter->cvGray)
cvReleaseImage (&filter->cvGray);
if (filter->cvStorage)
cvReleaseMemStorage (&filter->cvStorage);
g_free (filter->face_profile);
g_free (filter->nose_profile);
g_free (filter->mouth_profile);
g_free (filter->eyes_profile);
if (filter->cvFaceDetect)
cvReleaseHaarClassifierCascade (&filter->cvFaceDetect);
if (filter->cvNoseDetect)
cvReleaseHaarClassifierCascade (&filter->cvNoseDetect);
if (filter->cvMouthDetect)
cvReleaseHaarClassifierCascade (&filter->cvMouthDetect);
if (filter->cvEyesDetect)
cvReleaseHaarClassifierCascade (&filter->cvEyesDetect);
G_OBJECT_CLASS (gst_face_detect_parent_class)->finalize (obj);
}
int main(int argc, char* argv[]) {
CvHaarClassifierCascade *pCascadeFrontal = 0, *pCascadeProfile = 0;
CvMemStorage *pStorage = 0;
CvSeq *pFaceRectSeq;
int i;
IplImage *pInpImg = cvLoadImage("D:/²âÊÔ/test6.2/6.jpg", CV_LOAD_IMAGE_COLOR);
pStorage = cvCreateMemStorage(0);
pCascadeFrontal = (CvHaarClassifierCascade *) cvLoad ("D:/²âÊÔ/test6.2/haarcascade/haarcascade_frontalface_default.xml",0,0,0);
pCascadeProfile = (CvHaarClassifierCascade *) cvLoad ("D:/²âÊÔ/test6.2/haarcascade/haarcascade_profileface.xml",0,0,0);
if (!pInpImg || !pStorage || !pCascadeFrontal || !pCascadeProfile) {
printf("L'initilisation a echoue");
exit(-1);
}
cvNamedWindow("Fenetre de Haar", CV_WINDOW_NORMAL);
cvShowImage("Fenetre de Haar", pInpImg);
cvWaitKey(50);
pFaceRectSeq = cvHaarDetectObjects
(pInpImg, pCascadeFrontal, pStorage,1.1,3,CV_HAAR_DO_CANNY_PRUNING,cvSize(0, 0));
for (i=0 ; i < (pFaceRectSeq ? pFaceRectSeq->total : 0) ; i++) {
CvRect* r = (CvRect*)cvGetSeqElem(pFaceRectSeq, i);
CvPoint pt1 = { r->x, r->y };
CvPoint pt2 = { r->x + r->width, r->y + r->height };
cvRectangle(pInpImg, pt1, pt2, CV_RGB(0,255,0), 3, 4, 0);
cvSetImageROI(pInpImg, *r);
cvSmooth(pInpImg, pInpImg, CV_GAUSSIAN, 5, 3);
cvResetImageROI(pInpImg);
}
cvShowImage("Fenetre de Haar", pInpImg);
cvWaitKey(1);
//²àÁ³
pFaceRectSeq = cvHaarDetectObjects
(pInpImg, pCascadeProfile, pStorage,
1.4,3,CV_HAAR_DO_CANNY_PRUNING,cvSize(0, 0));
for (i=0 ; i < (pFaceRectSeq ? pFaceRectSeq->total : 0) ; i++) {
CvRect* r = (CvRect*)cvGetSeqElem(pFaceRectSeq, i);
CvPoint pt1 = { r->x, r->y };
CvPoint pt2 = { r->x + r->width, r->y + r->height };
cvRectangle(pInpImg, pt1, pt2, CV_RGB(255,165,0), 3, 4, 0);
cvSetImageROI(pInpImg, *r);
cvSmooth(pInpImg, pInpImg, CV_GAUSSIAN, 5, 3);
cvResetImageROI(pInpImg);
}
cvShowImage("Fenetre de Haar", pInpImg);
cvWaitKey(0);
cvDestroyWindow("Fenetre de Haar");
cvReleaseImage(&pInpImg);
if (pCascadeFrontal) cvReleaseHaarClassifierCascade(&pCascadeFrontal);
if (pCascadeProfile) cvReleaseHaarClassifierCascade(&pCascadeProfile);
if (pStorage) cvReleaseMemStorage(&pStorage);
}
int main(int argc, char **argv) {
CvCapture *capture;
IplImage *frame;
int key;
char *filename = "usb.xml"; // Change to the name of classifier
cascade = (CvHaarClassifierCascade *) cvLoad(filename, 0, 0, 0);
storage = cvCreateMemStorage(0);
capture = cvCaptureFromCAM(0);
// Check
// assert(cascade && storage && capture);
cvNamedWindow("video", 1);
while(1) {
frame = cvQueryFrame(capture);
detect(frame);
key = cvWaitKey(50);
}
cvReleaseImage(&frame);
cvReleaseCapture(&capture);
cvDestroyWindow("video");
cvReleaseHaarClassifierCascade(&cascade);
cvReleaseMemStorage(&storage);
return 0;
}
DLLEXP void ReleaseAlign()
{
delete []g_lefta;
delete []g_righta;
cvReleaseHaarClassifierCascade(&g_FDcascade);
cvReleaseMemStorage(&g_FDstorage);
}
vector<RECT> facedetect (string imagefilename, string classifierfilename)
{
CvHaarClassifierCascade* cascade = (CvHaarClassifierCascade*)cvLoad(classifierfilename.c_str());
IplImage* image = cvLoadImage(imagefilename);
CvMemStorage* storage = cvCreateMemStorage ( );
vector<RECT> list;
if( cascade && image && storage )
{
CvSeq* faces = cvHaarDetectObjects( img, cascade, storage, 1.1, 2, CV_HAAR_DO_CANNY_PRUNING, cvSize(40, 40) );
for( int i = 0; i < (faces ? faces->total : 0); i++ )
{
CvRect* r = (CvRect*)cvGetSeqElem( faces, i );
RECT rect ;
rect.left = r->x;
rect.right = r->x + r->width;
rect.top = r->y;
rect.bottom = r->y + r->height;
list.push_back(rect);
}
}
cvReleaseMemStorage(&storage);
cvReleaseImage(&image);
cvReleaseHaarClassifierCascade(&cascade);
return
}
/***************************************************************************
* 函数名称
* MatchPicture
* 参数
* CString imgPath - 图像的路径
* CString xmlPath - 模板路径
* 返回值
* CPoint -返回匹配区域的中心坐标，若检测不到则返回（0，0）
* 说明
* 该函数进行图片区域识别
***************************************************************************/
CPoint CMyImage::MatchPicture(CString imgPath,CString xmlPath)
{
CPoint centerPoint;
CvHaarClassifierCascade* cascade = 0;
cascade = (CvHaarClassifierCascade*)cvLoad(xmlPath); //加载特征文件
if( !cascade )
{
return CPoint(0,0);
}
IplImage* image = cvLoadImage( imgPath,1); //加载等待检测的图像
if(image)
{
centerPoint = Detect_and_Draw(image,cascade,0); //目标检测
cvWaitKey(0);
cvReleaseImage(&image);
}
else
{
return CPoint(0,0);
}
cvReleaseHaarClassifierCascade( &cascade); //释放
return centerPoint;
}
// Release all of the memory used by face tracking.
JNIEXPORT
void
JNICALL
Java_org_siprop_opencv_OpenCV_releaseFaceDetection(JNIEnv* env,
jobject thiz) {
m_facesFound = 0;
m_faceCropArea.width = m_faceCropArea.height = 0;
if (m_cascade) {
cvReleaseHaarClassifierCascade(&m_cascade);
m_cascade = 0;
}
if (m_sourceImage) {
cvReleaseImage(&m_sourceImage);
m_sourceImage = 0;
}
if (m_grayImage) {
cvReleaseImage(&m_grayImage);
m_grayImage = 0;
}
if (m_smallImage) {
cvReleaseImage(&m_smallImage);
m_smallImage = 0;
}
if (m_storage) {
cvReleaseMemStorage(&m_storage);
m_storage = 0;
}
}
void reinit_detection(char* cascade_location) {
if (cascade)
{
cvReleaseHaarClassifierCascade(&cascade);
}
cascade = (CvHaarClassifierCascade*)cvLoad( cascade_location, 0, 0, 0 );
}
void addFace(char *filename,char *personName)
{
IplImage* pInpImg=0;
CvHaarClassifierCascade* pCascade=0; //指向后面从文件中获取的分类器
CvMemStorage* pStorage=0; //存储检测到的人脸数据
CvSeq* pFaceRectSeq;
pStorage=cvCreateMemStorage(0); //创建默认大先64k的动态内存区域
pCascade=(CvHaarClassifierCascade*)cvLoad("d:/tools/opencv/data/haarcascades/haarcascade_frontalface_alt2.xml"); //加载分类器
cvLoadImage(filename);
if (!pInpImg||!pStorage||!pCascade)
{
printf("initialization failed:%s\n",(!pInpImg)?"can't load image file":(!pCascade)?"can't load haar-cascade---make sure path is correct":"unable to allocate memory for data storage",argv[1]);
return ;
}
//人脸检测
pFaceRectSeq=cvHaarDetectObjects(pInpImg,pCascade,pStorage,
1.2,2,CV_HAAR_DO_CANNY_PRUNING,cvSize(40,40));
//将检测到的人脸以矩形框标出。
IplImage *reuslt;
displaydetection(pInpImg,pFaceRectSeq,filename,reuslt);
cvReleaseImage(&pInpImg);
cvReleaseHaarClassifierCascade(&pCascade);
cvReleaseMemStorage(&pStorage);
}
int main(int argc,char **argv)
{
if(argc != 2)
{
printf("usage: %s <mode>\n0 - integrate webcam\n1 - external webcam\n",argv[0]);
exit(-1);
}
else
{
int web=atoi(argv[1]);
if(web >= 0 && web <= 1)
{
//Questo è il frame
IplImage *frame,*ridotta;
//Immagine dalla cam
CvCapture *immagine;
//Creo uno spazio di memoria
CvMemStorage *spazio=cvCreateMemStorage(0);
//Carico il file cascade -IMPORTANTE PER IL FUNZIONAMENTO DEL TRACKING-
CvHaarClassifierCascade *cascade = (CvHaarClassifierCascade*) cvLoad(FILE_FACCIA_1,spazio);
//Prendo i dati dalla cam
immagine = cvCaptureFromCAM(web);
cvSetCaptureProperty(immagine,CV_CAP_PROP_FRAME_WIDTH,640);
cvSetCaptureProperty(immagine,CV_CAP_PROP_FRAME_HEIGHT,480);
//Salvo il frame
frame = cvQueryFrame(immagine);
//Creo la finestra
cvNamedWindow(NOME_FINESTRA1,CV_WINDOW_AUTOSIZE);
//Ciclo finchè ci sono frame
while(frame)
{
cvFlip(frame,frame,1);
frame = diminuisci(frame,50);
//Rilevo il volto e i relativi dettagli
rilevaVolto(frame,cascade,spazio);
//Mostra l'immagine
cvShowImage(NOME_FINESTRA1,frame);
//Libero lo spazio
cvClearMemStorage(spazio);
//Prende un altro frame
frame = cvQueryFrame(immagine);
//Aspetta 10 ms per controllare se viene premuto il tasto q (per uscire)
char c = cvWaitKey(15);
if(c == 'q') break;
}
cvReleaseHaarClassifierCascade(&cascade);
cvReleaseCapture(&immagine);
cvReleaseImage(&frame);
cvDestroyWindow(NOME_FINESTRA1);
}
else
puts("webcam not found");
}
return 0;
}
VALUE
cvhaarclassifiercascade_free(void* ptr)
{
if (ptr) {
CvHaarClassifierCascade* cascade = (CvHaarClassifierCascade*)ptr;
cvReleaseHaarClassifierCascade(&cascade);
}
}
FaceBl0r::~FaceBl0r() {
if(tracked_obj)
destroy_tracked_object(tracked_obj);
if(cascade) cvReleaseHaarClassifierCascade(&cascade);
if(storage) cvReleaseMemStorage(&storage);
}
ImgProcessing::~ImgProcessing() {
/** Free model **/
if (model != 0)
svm_free_and_destroy_model(&model);
/** Free face detection classifier & storage **/
cvReleaseMemStorage( &storage );
cvReleaseHaarClassifierCascade( &cascade );
}
static void
gst_face_blur_load_profile (GstFaceBlur * filter)
{
if (filter->cvCascade)
cvReleaseHaarClassifierCascade (&filter->cvCascade);
filter->cvCascade =
(CvHaarClassifierCascade *) cvLoad (filter->profile, 0, 0, 0);
if (!filter->cvCascade)
GST_WARNING ("Couldn't load Haar classifier cascade: %s.", filter->profile);
}
/*! \fn FaceDetectorPlugin::_loadHaarCascade(string sConfigPath)
* \param sConfigPath is path to xml Haar classifier cascade.
*/
void FaceDetectorPlugin::_loadHaarCascade(string sConfigPath)
{
m_sHaarCascadePath = sConfigPath;
if (m_cascade != NULL)
cvReleaseHaarClassifierCascade(&m_cascade);
m_cascade = (CvHaarClassifierCascade*)cvLoad(sConfigPath.c_str());
if (m_cascade == NULL)
throw invalid_argument((string("Couldn't load xml data: ") + sConfigPath + ".").c_str());
}
void release_detection() {
if (storage)
{
cvReleaseMemStorage(&storage);
}
if (cascade)
{
cvReleaseHaarClassifierCascade(&cascade);
}
//cvReleaseImage(&gray);
//cvReleaseImage(&small_img);
}
void release_detection_multiple() {
if (storage)
{
cvReleaseMemStorage(&storage);
}
if (face_cascade)
{
cvReleaseHaarClassifierCascade(&face_cascade);
}
if (nose_cascade)
{
cvReleaseHaarClassifierCascade(&nose_cascade);
}
if (mouth_cascade)
{
cvReleaseHaarClassifierCascade(&mouth_cascade);
}
if (leye_cascade)
{
cvReleaseHaarClassifierCascade(&leye_cascade);
}
if (reye_cascade)
{
cvReleaseHaarClassifierCascade(&reye_cascade);
}
if (profile_face_cascade)
{
cvReleaseHaarClassifierCascade(&profile_face_cascade);
}
//if(gray) cvReleaseImage(&gray);
//if(small_img) cvReleaseImage(&small_img);
}
/*****************************************************************************
* CloseFilter: clean up the filter
*****************************************************************************/
static void CloseFilter( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t*)p_this;
filter_sys_t *p_sys = p_filter->p_sys;
if( p_sys->p_cascade )
cvReleaseHaarClassifierCascade( &p_sys->p_cascade );
if( p_sys->p_storage )
cvReleaseMemStorage( &p_sys->p_storage );
free( p_sys->event_info.p_region );
free( p_sys );
var_Destroy( p_filter->p_libvlc, VIDEO_FILTER_EVENT_VARIABLE);
}
ReturnType getCamComp::onDestroy() {
if(face_cascade) cvReleaseHaarClassifierCascade(&face_cascade);
//if(eye_cascade) cvReleaseHaarClassifierCascade(&eye_cascade);
// clean up and release resources
if(frame!=NULL) cvReleaseImage(&frame);
if(pStorageface) cvReleaseMemStorage(&pStorageface);
//if(pStorageeye) cvReleaseMemStorage(&pStorageeye);
if(capture!=NULL)cvReleaseCapture( &capture );
return OPROS_SUCCESS; }
void Process::setHaarFile(string file)
{
wait();
if ( file == "" )
return;
if (haarCascade) {
cvReleaseHaarClassifierCascade(&haarCascade);
}
haarCascade = (CvHaarClassifierCascade *)cvLoad(file.c_str(), 0, 0, 0);
if (!haarCascade)
qDebug() << "Error open cascade file:" << QString(file.c_str());
else
qDebug() << "Open cascade file:" << QString(file.c_str());
}
int main( int argc, char** argv )
{
IplImage* image;
//Use the following line to use your image
if((image = cvLoadImage( "u00001.png", 1 )) != 0 )
{
CvHaarClassifierCascade* cascade = (CvHaarClassifierCascade*)cvLoad("data/cascade.xml", 0, 0, 0);
detect_and_draw_objects( image, cascade, 1 );
cvNamedWindow( "test", 0 );
cvShowImage( "test", image );
cvWaitKey(0);
cvReleaseHaarClassifierCascade( &cascade );
cvReleaseImage( &image );
}
return 0;
}
void asef_destroy(AsefEyeLocator *asef){
cvReleaseMemStorage( &asef->face_detection_buffer );
cvReleaseHaarClassifierCascade( &asef->face_detection_classifier );
cvReleaseMat(&asef->lfilter);
cvReleaseMat(&asef->rfilter);
cvReleaseMat(&asef->lfilter_dft);
cvReleaseMat(&asef->rfilter_dft);
cvReleaseMat(&asef->scaled_face_image_32fc1);
cvReleaseMat(&asef->scaled_face_image_8uc1);
cvReleaseMat(&asef->lcorr);
cvReleaseMat(&asef->rcorr);
cvReleaseMat(&asef->lroi);
cvReleaseMat(&asef->rroi);
cvReleaseMat(&asef->lut);
}
int main(void)
{
double wsize = 320;
double hsize = 240;
cvNamedWindow("FaceDetection", CV_WINDOW_AUTOSIZE);
CvCapture* capture = NULL;
capture = cvCreateCameraCapture(0);
cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_WIDTH, wsize);
cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_HEIGHT, hsize);
IplImage* frame;
CvHaarClassifierCascade* cvHCC = (CvHaarClassifierCascade*)cvLoad("/usr/share/opencv/haarcascades/haarcascade_frontalface_alt.xml");
CvMemStorage* cvMStr = cvCreateMemStorage(0);
CvSeq* face;
while(1)
{
frame = cvQueryFrame(capture);
if(!frame) break;
face = cvHaarDetectObjects(frame, cvHCC, cvMStr);
for (int i = 0; i < face->total; i++)
{
CvRect* faceRect = (CvRect*)cvGetSeqElem(face, i);
cvRectangle(frame,
cvPoint(faceRect->x, faceRect->y),
cvPoint(faceRect->x + faceRect->width, faceRect->y + faceRect->height),
CV_RGB(255, 0 ,0),
2, CV_AA);
}
cvShowImage("FaceDetection", frame);
if(cvWaitKey(33)==27) break;
}
cvReleaseMemStorage(&cvMStr);
cvReleaseHaarClassifierCascade(&cvHCC);
cvReleaseCapture( &capture );
cvDestroyWindow("FaceDetection");
}
/* Clean up */
static void
gst_face_blur_finalize (GObject * obj)
{
GstFaceBlur *filter = GST_FACE_BLUR (obj);
if (filter->cvGray)
cvReleaseImage (&filter->cvGray);
if (filter->cvStorage)
cvReleaseMemStorage (&filter->cvStorage);
if (filter->cvCascade)
cvReleaseHaarClassifierCascade (&filter->cvCascade);
g_free (filter->profile);
G_OBJECT_CLASS (gst_face_blur_parent_class)->finalize (obj);
}
int main( int argc, char** argv )
{
CvCapture *capture;
IplImage *frame;
int key;
//NamNguyen comment and add(2lines below)
//char *filename = "haarcascade_frontalface_alt.xml";
char filename[] = "haarcascade_frontalface_alt.xml";
cascade = ( CvHaarClassifierCascade* )cvLoad( filename, 0, 0, 0 );
storage = cvCreateMemStorage( 0 );
capture = cvCaptureFromCAM( 0 );
assert( cascade && storage && capture );
cvNamedWindow( "video", 1 );
while( key != 'q' ) {
frame = cvQueryFrame( capture );
if( !frame ) {
fprintf( stderr, "Cannot query frame!\n" );
break;
}
cvFlip( frame, frame, -1 );
frame->origin = 0;
detectFaces( frame );
key = cvWaitKey( 10 );
}
cvReleaseCapture( &capture );
cvDestroyWindow( "video" );
cvReleaseHaarClassifierCascade( &cascade );
cvReleaseMemStorage( &storage );
return 0;
}
void QOpenCvImageBox::setSubDetectionEnabled(bool value) {
subDetectionEnabled=value;
if (subDetectionEnabled) {
// FD initialization
detected_sub_objs_array=NULL;
sub_objs_found=0;
sub_objs_visible=0;
sub_od_calc_time=0;
sub_od_image_scale=DEFAULT_SUB_IMAGE_SIZE;
sub_cascade = (CvHaarClassifierCascade*)cvLoad(sub_obj_cascade_name->toLatin1(), 0, 0, 0 );
if(!sub_cascade)
{
printf("Could not open cascade classifier %s", cascade_name);
}
} else {
cvReleaseHaarClassifierCascade(&sub_cascade);
}
}
static void
kms_face_detector_finalize (GObject * object)
{
KmsFaceDetector *facedetector = KMS_FACE_DETECTOR (object);
cvReleaseImageHeader (&facedetector->priv->cvImage);
cvReleaseImage (&facedetector->priv->cvResizedImage);
if (facedetector->priv->pStorageFace != NULL)
cvClearMemStorage (facedetector->priv->pStorageFace);
if (facedetector->priv->pFaceRectSeq != NULL)
cvClearSeq (facedetector->priv->pFaceRectSeq);
cvReleaseMemStorage (&facedetector->priv->pStorageFace);
cvReleaseHaarClassifierCascade (&facedetector->priv->pCascadeFace);
g_mutex_clear (&facedetector->priv->mutex);
G_OBJECT_CLASS (kms_face_detector_parent_class)->finalize (object);
}
void detectFace(
IplImage* srcImg, // 灰度图像
CvSeq* objects, // 输出参数：检测到人脸的矩形框
CvMemStorage* storage, // 存储矩形框的内存区域
double scale_factor = 1.1, // 搜索窗口的比例系数
int min_neighbors = 3, // 构成检测目标的相邻矩形的最小个数
int flags = 0, // 操作方式
CvSize min_size = cvSize(20, 20) // 检测窗口的最小尺寸
)
{
// 程序用到的参数
const char* cascadeName = "haarcascade_frontalface_alt2.xml"; // 级联分类器的xml文件名
// 读取级联分类器xml文件
CvHaarClassifierCascade* cascade = (CvHaarClassifierCascade*)cvLoad(cascadeName, 0, 0, 0);
if( !cascade ) {
fprintf( stderr, "ERROR: Could not load classifier cascade\n" );
cvWaitKey(0);
exit(-1);
}
// 直方图均衡
//cvEqualizeHist(srcImg ,srcImg);
// 检测人脸
cvClearMemStorage(storage);
objects = cvHaarDetectObjects(
srcImg,
cascade,
storage,
scale_factor,
min_neighbors,
flags, /*CV_HAAR_DO_CANNY_PRUNING*/
min_size
);
objectsTemp = objects; // 为了将objects的值传递回main函数
// 释放cascade的内存
cvReleaseHaarClassifierCascade(&cascade);
}
void ofxCvHaarFinder::setup(string haarFile) {
if(cascade != NULL)
cvReleaseHaarClassifierCascade(&cascade);
this->haarFile = haarFile;
haarFile = ofToDataPath(haarFile);
cascade = (CvHaarClassifierCascade*) cvLoad(haarFile.c_str(), 0, 0, 0);
#ifdef HAAR_HACK
// http://thread.gmane.org/gmane.comp.lib.opencv/16540/focus=17400
// http://www.openframeworks.cc/forum/viewtopic.php?f=10&t=1853&hilit=haar
ofxCvGrayscaleImage hack;
hack.allocate(8, 8);
CvMemStorage* storage = cvCreateMemStorage();
cvHaarDetectObjects(hack.getCvImage(), cascade, storage, scaleHaar, 2, CV_HAAR_DO_CANNY_PRUNING);
cvReleaseMemStorage(&storage);
#endif
if (!cascade)
printf("Could not load Haar cascade: %s\n", haarFile.c_str());
}
face_detect_ctx::~face_detect_ctx()
{
if(this->temp_storage) cvReleaseImage(&this->temp_storage);
if(this->small_image) cvReleaseImage(&this->small_image);
vector<CvRect *>::iterator it;
if(this->face_vector->size() > 0)
{
for(it=this->face_vector->begin();it!=this->face_vector->end();) delete *it++;
this->face_vector->erase(this->face_vector->begin(),this->face_vector->end());
}
if(this->body_vector->size() > 0)
{
for(it=this->body_vector->begin();it!=this->body_vector->end();) delete *it++;
this->body_vector->erase(this->body_vector->begin(),this->body_vector->end());
}
delete this->face_vector;
delete this->body_vector;
cvReleaseHaarClassifierCascade( &this->cascade );
this->faceconf=NULL;
}
