void
cupsImageWhiteToRGB(
const cups_ib_t *in, /* I - Input pixels */
cups_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
if (cupsImageHaveProfile)
{
while (count > 0)
{
out[0] = 255 - cupsImageDensity[255 - *in++];
out[1] = out[0];
out[2] = out[0];
out += 3;
count --;
}
}
else
{
while (count > 0)
{
*out++ = *in;
*out++ = *in;
*out++ = *in++;
if (cupsImageColorSpace == CUPS_CSPACE_CIELab ||
cupsImageColorSpace >= CUPS_CSPACE_ICC1)
rgb_to_lab(out - 3);
else if (cupsImageColorSpace == CUPS_CSPACE_CIEXYZ)
rgb_to_xyz(out - 3);
count --;
}
}
}
inline value_type convert(const value_type& v, ColorSpaceType input, ColorSpaceType output) {
if (input == ColorSpaceRGB) {
if (output == ColorSpaceRGB) return v;
if (output == ColorSpaceYUV) return rgb_to_yuv(v);
if (output == ColorSpaceLAB) return rgb_to_lab(v);
}
if (input == ColorSpaceYUV) {
if (output == ColorSpaceRGB) return yuv_to_rgb(v);
if (output == ColorSpaceYUV) return v;
if (output == ColorSpaceLAB) return yuv_to_lab(v);
}
if (input == ColorSpaceLAB) {
if (output == ColorSpaceRGB) return lab_to_rgb(v);
if (output == ColorSpaceYUV) return lab_to_yuv(v);
if (output == ColorSpaceLAB) return v;
}
return value_type::Zero();
}
void LABImage::setImage(RGBImage* prgb)
{
float* labpix;
png_bytep rgbpixels = prgb->getPixels();
width = (int)prgb->getWidth();
height = (int)prgb->getHeight();
if(pixels == NULL)
pixels = (float*)malloc(sizeof(float)*width*height*3);
else
pixels = (float*)realloc(pixels, sizeof(float)*width*height*3);
unsigned char rdat, gdat, bdat;
for(uint32_t i = 0; i < (uint32_t)width*height; i++)
{
rdat = *(rgbpixels +i*3);
gdat = *(rgbpixels +i*3 +1);
bdat = *(rgbpixels +i*3 +2);
labpix = pixels+i*3;
rgb_to_lab(labpix, rdat, gdat, bdat);
}
}
float* LABImage::getLAB(unsigned char r, unsigned char g, unsigned char b)
{
float* lab = (float*)malloc(sizeof(float)*3);
rgb_to_lab(lab, r, g, b);
return lab;
}
char* _process_frame_tickertext(struct lib_hardsubx_ctx *ctx, AVFrame *frame, int width, int height, int index)
{
PIX *im;
PIX *edge_im;
PIX *lum_im;
PIX *feat_im;
char *subtitle_text=NULL;
im = pixCreate(width,height,32);
lum_im = pixCreate(width,height,32);
feat_im = pixCreate(width,height,32);
int i,j;
for(i=(92*height)/100;i<height;i++)
{
for(j=0;j<width;j++)
{
int p=j*3+i*frame->linesize[0];
int r=frame->data[0][p];
int g=frame->data[0][p+1];
int b=frame->data[0][p+2];
pixSetRGBPixel(im,j,i,r,g,b);
float L,A,B;
rgb_to_lab((float)r,(float)g,(float)b,&L,&A,&B);
if(L > ctx->lum_thresh)
pixSetRGBPixel(lum_im,j,i,255,255,255);
else
pixSetRGBPixel(lum_im,j,i,0,0,0);
}
}
//Handle the edge image
edge_im = pixCreate(width,height,8);
edge_im = pixConvertRGBToGray(im,0.0,0.0,0.0);
edge_im = pixSobelEdgeFilter(edge_im, L_VERTICAL_EDGES);
edge_im = pixDilateGray(edge_im, 21, 11);
edge_im = pixThresholdToBinary(edge_im,50);
for(i=92*(height/100);i<height;i++)
{
for(j=0;j<width;j++)
{
unsigned int p1,p2,p3;
pixGetPixel(edge_im,j,i,&p1);
// pixGetPixel(pixd,j,i,&p2);
pixGetPixel(lum_im,j,i,&p3);
if(p1==0&&p3>0)
pixSetRGBPixel(feat_im,j,i,255,255,255);
else
pixSetRGBPixel(feat_im,j,i,0,0,0);
}
}
// Tesseract OCR for the ticker text here
subtitle_text = get_ocr_text_simple(ctx, lum_im);
char write_path[100];
sprintf(write_path,"./lum_im%04d.jpg",index);
pixWrite(write_path,lum_im,IFF_JFIF_JPEG);
sprintf(write_path,"./im%04d.jpg",index);
pixWrite(write_path,im,IFF_JFIF_JPEG);
pixDestroy(&lum_im);
pixDestroy(&im);
pixDestroy(&edge_im);
pixDestroy(&feat_im);
return subtitle_text;
}
char* _process_frame_white_basic(struct lib_hardsubx_ctx *ctx, AVFrame *frame, int width, int height, int index)
{
//printf("frame : %04d\n", index);
PIX *im;
PIX *edge_im;
PIX *lum_im;
PIX *feat_im;
char *subtitle_text=NULL;
im = pixCreate(width,height,32);
lum_im = pixCreate(width,height,32);
feat_im = pixCreate(width,height,32);
int i,j;
for(i=(3*height)/4;i<height;i++)
{
for(j=0;j<width;j++)
{
int p=j*3+i*frame->linesize[0];
int r=frame->data[0][p];
int g=frame->data[0][p+1];
int b=frame->data[0][p+2];
pixSetRGBPixel(im,j,i,r,g,b);
float L,A,B;
rgb_to_lab((float)r,(float)g,(float)b,&L,&A,&B);
if(L > ctx->lum_thresh)
pixSetRGBPixel(lum_im,j,i,255,255,255);
else
pixSetRGBPixel(lum_im,j,i,0,0,0);
}
}
//Handle the edge image
edge_im = pixCreate(width,height,8);
edge_im = pixConvertRGBToGray(im,0.0,0.0,0.0);
edge_im = pixSobelEdgeFilter(edge_im, L_VERTICAL_EDGES);
edge_im = pixDilateGray(edge_im, 21, 11);
edge_im = pixThresholdToBinary(edge_im,50);
for(i=3*(height/4);i<height;i++)
{
for(j=0;j<width;j++)
{
unsigned int p1,p2,p3;
pixGetPixel(edge_im,j,i,&p1);
// pixGetPixel(pixd,j,i,&p2);
pixGetPixel(lum_im,j,i,&p3);
if(p1==0&&p3>0)
pixSetRGBPixel(feat_im,j,i,255,255,255);
else
pixSetRGBPixel(feat_im,j,i,0,0,0);
}
}
if(ctx->detect_italics)
{
ctx->ocr_mode = HARDSUBX_OCRMODE_WORD;
}
// TESSERACT OCR FOR THE FRAME HERE
switch(ctx->ocr_mode)
{
case HARDSUBX_OCRMODE_WORD:
if(ctx->conf_thresh > 0)
subtitle_text = get_ocr_text_wordwise_threshold(ctx, lum_im, ctx->conf_thresh);
else
subtitle_text = get_ocr_text_wordwise(ctx, lum_im);
break;
case HARDSUBX_OCRMODE_LETTER:
if(ctx->conf_thresh > 0)
subtitle_text = get_ocr_text_letterwise_threshold(ctx, lum_im, ctx->conf_thresh);
else
subtitle_text = get_ocr_text_letterwise(ctx, lum_im);
break;
case HARDSUBX_OCRMODE_FRAME:
if(ctx->conf_thresh > 0)
subtitle_text = get_ocr_text_simple_threshold(ctx, lum_im, ctx->conf_thresh);
else
subtitle_text = get_ocr_text_simple(ctx, lum_im);
break;
default:
fatal(EXIT_MALFORMED_PARAMETER,"Invalid OCR Mode");
}
pixDestroy(&lum_im);
pixDestroy(&im);
pixDestroy(&edge_im);
pixDestroy(&feat_im);
return subtitle_text;
}
int main(int argc, char **argv){
if( argc<6){
if(argc>1) fprintf(stderr,"Error, not enough arguments\n");
usage();
exit(1);
}
// read arguments
color_image_t *im1 = color_image_load(argv[1]);
color_image_t *im2 = color_image_load(argv[2]);
float_image edges = read_edges(argv[3], im1->width, im1->height);
float_image matches = read_matches(argv[4]);
const char *outputfile = argv[5];
// prepare variables
epic_params_t epic_params;
epic_params_default(&epic_params);
variational_params_t flow_params;
variational_params_default(&flow_params);
image_t *wx = image_new(im1->width, im1->height), *wy = image_new(im1->width, im1->height);
// read optional arguments
#define isarg(key) !strcmp(a,key)
int current_arg = 6;
while(current_arg < argc ){
const char* a = argv[current_arg++];
if( isarg("-h") || isarg("-help") )
usage();
else if( isarg("-nw") )
strcpy(epic_params.method, "NW");
else if( isarg("-p") || isarg("-prefnn") )
epic_params.pref_nn = atoi(argv[current_arg++]);
else if( isarg("-n") || isarg("-nn") )
epic_params.nn = atoi(argv[current_arg++]);
else if( isarg("-k") )
epic_params.coef_kernel = atof(argv[current_arg++]);
else if( isarg("-i") || isarg("-iter") )
flow_params.niter_outer = atoi(argv[current_arg++]);
else if( isarg("-a") || isarg("-alpha") )
flow_params.alpha= atof(argv[current_arg++]);
else if( isarg("-g") || isarg("-gamma") )
flow_params.gamma= atof(argv[current_arg++]);
else if( isarg("-d") || isarg("-delta") )
flow_params.delta= atof(argv[current_arg++]);
else if( isarg("-s") || isarg("-sigma") )
flow_params.sigma= atof(argv[current_arg++]);
else if( isarg("-sintel") ){
epic_params.pref_nn= 25;
epic_params.nn= 160;
epic_params.coef_kernel = 1.1f;
flow_params.niter_outer = 5;
flow_params.alpha = 1.0f;
flow_params.gamma = 0.72f;
flow_params.delta = 0.0f;
flow_params.sigma = 1.1f;
}
else if( isarg("-kitti") ){
epic_params.pref_nn= 25;
epic_params.nn= 160;
epic_params.coef_kernel = 1.1f;
flow_params.niter_outer = 2;
flow_params.alpha = 1.0f;
flow_params.gamma = 0.77f;
flow_params.delta = 0.0f;
flow_params.sigma = 1.7f;
}
else if( isarg("-middlebury") ){
epic_params.pref_nn= 15;
epic_params.nn= 65;
epic_params.coef_kernel = 0.2f;
flow_params.niter_outer = 25;
flow_params.alpha = 1.0f;
flow_params.gamma = 0.72f;
flow_params.delta = 0.0f;
flow_params.sigma = 1.1f;
}
else{
fprintf(stderr, "unknown argument %s", a);
usage();
exit(1);
}
}
// compute interpolation and energy minimization
color_image_t *imlab = rgb_to_lab(im1);
epic(wx, wy, imlab, &matches, &edges, &epic_params, 1);
// energy minimization
variational(wx, wy, im1, im2, &flow_params);
// write output file and free memory
writeFlowFile(outputfile, wx, wy);
color_image_delete(im1);
color_image_delete(imlab);
color_image_delete(im2);
free(matches.pixels);
free(edges.pixels);
image_delete(wx);
image_delete(wy);
return 0;
}
inline value_type yuv_to_lab(const value_type& v) {
return rgb_to_lab(yuv_to_rgb(v));
}
void
cupsImageRGBToRGB(
const cups_ib_t *in, /* I - Input pixels */
cups_ib_t *out, /* I - Output pixels */
int count) /* I - Number of pixels */
{
int c, m, y, k; /* CMYK values */
int cr, cg, cb; /* Calibrated RGB values */
if (cupsImageHaveProfile)
{
while (count > 0)
{
c = 255 - *in++;
m = 255 - *in++;
y = 255 - *in++;
k = min(c, min(m, y));
c -= k;
m -= k;
y -= k;
cr = cupsImageMatrix[0][0][c] +
cupsImageMatrix[0][1][m] +
cupsImageMatrix[0][2][y] + k;
cg = cupsImageMatrix[1][0][c] +
cupsImageMatrix[1][1][m] +
cupsImageMatrix[1][2][y] + k;
cb = cupsImageMatrix[2][0][c] +
cupsImageMatrix[2][1][m] +
cupsImageMatrix[2][2][y] + k;
if (cr < 0)
*out++ = 255;
else if (cr > 255)
*out++ = 255 - cupsImageDensity[255];
else
*out++ = 255 - cupsImageDensity[cr];
if (cg < 0)
*out++ = 255;
else if (cg > 255)
*out++ = 255 - cupsImageDensity[255];
else
*out++ = 255 - cupsImageDensity[cg];
if (cb < 0)
*out++ = 255;
else if (cb > 255)
*out++ = 255 - cupsImageDensity[255];
else
*out++ = 255 - cupsImageDensity[cb];
count --;
}
}
else
{
if (in != out)
memcpy(out, in, count * 3);
if (cupsImageColorSpace == CUPS_CSPACE_CIELab ||
cupsImageColorSpace >= CUPS_CSPACE_ICC1)
{
while (count > 0)
{
rgb_to_lab(out);
out += 3;
count --;
}
}
else if (cupsImageColorSpace == CUPS_CSPACE_CIEXYZ)
{
while (count > 0)
{
rgb_to_xyz(out);
out += 3;
count --;
}
}
}
}
