DUI_ImageButton::~DUI_ImageButton()
{
if (m_bAutoReleaseImg)
{
ReleaseImages();
}
Destroy();
}
Texture::~Texture()
{
/**
*Release texture data
*/
ReleaseImages();
}
/*****************************************************************************
* Destroy: destroy opencv_wrapper video thread output method
*****************************************************************************
* Terminate an output method created by opencv_wrapperCreateOutputMethod
*****************************************************************************/
static void Destroy( vlc_object_t *p_this )
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
ReleaseImages(p_vout);
if( p_vout->p_sys->p_image )
image_HandlerDelete( p_vout->p_sys->p_image );
free( p_vout->p_sys );
}
/*****************************************************************************
* Destroy: destroy opencv_wrapper video thread output method
*****************************************************************************
* Terminate an output method created by opencv_wrapperCreateOutputMethod
*****************************************************************************/
static void Destroy( vlc_object_t *p_this )
{
filter_t* p_filter = (filter_t*)p_this;
ReleaseImages( p_filter );
// Release the internal OpenCV filter.
module_unneed( p_filter->p_sys->p_opencv, p_filter->p_sys->p_opencv->p_module );
vlc_object_release( p_filter->p_sys->p_opencv );
p_filter->p_sys->p_opencv = NULL;
free( p_filter->p_sys );
}
/*****************************************************************************
* Render: displays previously rendered output
*****************************************************************************
* This function send the currently rendered image to the internal opencv
* filter for processing.
*****************************************************************************/
static void Render( vout_thread_t *p_vout, picture_t *p_pic )
{
picture_t *p_outpic = NULL;
clock_t start, finish;
double duration;
while( ( p_outpic = vout_CreatePicture( p_vout->p_sys->p_vout, 0, 0, 0 ) )
== NULL )
{
if( !vlc_object_alive (p_vout) || p_vout->b_error )
{ return; }
msleep( VOUT_OUTMEM_SLEEP );
}
vout_LinkPicture( p_vout->p_sys->p_vout, p_outpic );
start = clock();
if (p_vout->p_sys->i_wrapper_output == VINPUT) //output = input video
{
//This copy is a bit unfortunate but image_Convert can't write into an existing image so it is better to copy the
//(say) 16bit YUV image here than a 32bit RGB image somehwere else.
//It is also not that expensive in time.
picture_Copy( p_outpic, p_pic );
VlcPictureToIplImage( p_vout, p_pic);
//pass the image to the internal opencv filter for processing
if ((p_vout->p_sys->p_opencv) && (p_vout->p_sys->p_opencv->p_module))
p_vout->p_sys->p_opencv->pf_video_filter( p_vout->p_sys->p_opencv, &(p_vout->p_sys->hacked_pic));
}
else //output = processed video (NONE option not working yet)
{
VlcPictureToIplImage( p_vout, p_pic);
//pass the image to the internal opencv filter for processing
if ((p_vout->p_sys->p_opencv) && (p_vout->p_sys->p_opencv->p_module))
p_vout->p_sys->p_opencv->pf_video_filter( p_vout->p_sys->p_opencv, &(p_vout->p_sys->hacked_pic));
//copy the processed image into the output image
if ((p_vout->p_sys->p_proc_image) && (p_vout->p_sys->p_proc_image->i_planes > 0))
picture_Copy( p_outpic, p_vout->p_sys->p_proc_image );
}
//calculate duration
finish = clock();
duration = (double)(finish - start) / CLOCKS_PER_SEC;
if (p_vout->p_sys->i_verbosity > VERB_WARN)
msg_Dbg( p_vout, "Render took %2.4f seconds", duration );
ReleaseImages(p_vout);
p_outpic->date = p_pic->date;
vout_UnlinkPicture( p_vout->p_sys->p_vout, p_outpic );
vout_DisplayPicture( p_vout->p_sys->p_vout, p_outpic );
}
int main(int argc, char** argv)
{
enum LEFT_RIGHT { LEFT=0, RIGHT=1 };
CommandlineUtils ArgList(argc, argv);
// Get left image set
int ImSetSizeL = 0;
char** ImNameL = ArgList.GetArgsByOption("-l", ImSetSizeL);
// Get right image set
int ImSetSizeR = 0;
char** ImNameR = ArgList.GetArgsByOption("-r", ImSetSizeR);
// Get square size
int size_len;
char** squareSizeStr = ArgList.GetArgsByOption("-d", size_len);
float squareSize = atof(squareSizeStr[0]);
// Get output name
int NameSize;
char** OutputName = ArgList.GetArgsByOption("-o", NameSize);
if(ImNameL == NULL)
{
std::cerr << "Empty left image set!" << std::endl;
return 0;
}
if(ImNameR == NULL)
{
std::cerr << "Empty right image set!" << std::endl;
return 0;
}
if(ImSetSizeL != ImSetSizeR)
{
std::cerr << "Unmatched number of images in left and right set" << std::endl;
return 0;
}
// int NumOfIm = ImSetSizeL;
// Get board size
int BoardDimension = 0;
char** BoardSize = ArgList.GetArgsByOption("-s", BoardDimension);
if(BoardDimension != 2)
{
std::cerr << "Only two dimensional checkerboard is supported!" << std::endl;
return 0;
}
int CornersX = atoi(BoardSize[0]);
int CornersY = atoi(BoardSize[1]);
// Load images
IplImage** ImSetL = LoadImages(ImNameL, ImSetSizeL);
IplImage** ImSetR = LoadImages(ImNameR, ImSetSizeR);
int ImWidth = ImSetL[0]->width;
int ImHeight = ImSetL[1]->height;
StereoVision sv;
// Initialize calibration
sv.calibrationInit(ImWidth, ImHeight, CornersX, CornersY);
// Calibrate left image set
sv.monoCalibrate(ImSetSizeL, ImSetL, LEFT);
sv.monoCalibrate(ImSetSizeR, ImSetR, RIGHT);
// Calibrate stereo pair
sv.stereoCalibrate(squareSize, ImSetSizeL, ImSetL, ImSetR);
// Output calibration result
sv.calibrationSave(OutputName[0]);
// Release images
ReleaseImages(ImSetL, ImSetSizeL);
ReleaseImages(ImSetR, ImSetSizeR);
return 0;
}
/*****************************************************************************
* Filter: displays previously rendered output
*****************************************************************************
* This function send the currently rendered image to the internal opencv
* filter for processing.
*****************************************************************************/
static picture_t* Filter( filter_t* p_filter, picture_t* p_pic )
{
picture_t* p_outpic = filter_NewPicture( p_filter );
if( p_outpic == NULL ) {
msg_Err( p_filter, "couldn't get a p_outpic!" );
picture_Release( p_pic );
return NULL;
}
video_format_t fmt_out;
// Make a copy if we want to show the original input
if (p_filter->p_sys->i_wrapper_output == VINPUT)
picture_Copy( p_outpic, p_pic );
VlcPictureToIplImage( p_filter, p_pic );
// Pass the image (as a pointer to the first IplImage*) to the
// internal OpenCV filter for processing.
p_filter->p_sys->p_opencv->pf_video_filter( p_filter->p_sys->p_opencv, (picture_t*)&(p_filter->p_sys->p_cv_image[0]) );
if(p_filter->p_sys->i_wrapper_output == PROCESSED) {
// Processed video
if( (p_filter->p_sys->p_proc_image) &&
(p_filter->p_sys->p_proc_image->i_planes > 0) &&
(p_filter->p_sys->i_internal_chroma != CINPUT) ) {
//p_filter->p_sys->p_proc_image->format.i_chroma = VLC_CODEC_RGB24;
memset( &fmt_out, 0, sizeof(video_format_t) );
fmt_out = p_pic->format;
//picture_Release( p_outpic );
/*
* We have to copy out the image from image_Convert(), otherwise
* you leak pictures for some reason:
* main video output error: pictures leaked, trying to workaround
*/
picture_t* p_outpic_tmp = image_Convert(
p_filter->p_sys->p_image,
p_filter->p_sys->p_proc_image,
&(p_filter->p_sys->p_proc_image->format),
&fmt_out );
picture_CopyPixels( p_outpic, p_outpic_tmp );
CopyInfoAndRelease( p_outpic, p_outpic_tmp );
} else if( p_filter->p_sys->i_internal_chroma == CINPUT ) {
picture_CopyPixels( p_outpic, p_filter->p_sys->p_proc_image );
picture_CopyProperties( p_outpic, p_filter->p_sys->p_proc_image );
}
}
ReleaseImages( p_filter );
picture_Release( p_pic );
#ifndef NDEBUG
msg_Dbg( p_filter, "Filter() done" );
#endif
if( p_filter->p_sys->i_wrapper_output != NONE ) {
return p_outpic;
} else { // NONE
picture_Release( p_outpic );
return NULL;
}
}
MythUIEditBar::~MythUIEditBar(void)
{
ReleaseImages();
}
