int bitbltColorRGB(unsigned char * target, unsigned int tX, unsigned int tY , unsigned int targetWidth , unsigned int targetHeight ,
unsigned char R , unsigned char G , unsigned char B ,
unsigned int width , unsigned int height)
{
//Check for bounds -----------------------------------------
if (tX+width>=targetWidth) { width=targetWidth-tX-1; }
if (tY+height>=targetHeight) { height=targetHeight-tY-1; }
//----------------------------------------------------------
unsigned char * targetPTR; unsigned char * targetLineLimitPTR; unsigned char * targetLimitPTR; unsigned int targetLineSkip;
targetPTR = target + MEMPLACE3(tX,tY,targetWidth);
targetLimitPTR = target + MEMPLACE3((tX+width),(tY+height),targetWidth);
targetLineSkip = (targetWidth-width) * 3;
targetLineLimitPTR = targetPTR + (width*3) -3; /*-3 is required here*/
fprintf(stderr,"BitBlt Color an area (%u,%u) of target image starting at %u,%u sized %u,%u with color RGB(%u,%u,%u)\n",width,height,tX,tY,targetWidth,targetHeight,R,G,B);
fprintf(stderr,"last Pixels @ %u,%u\n",tX+width,tY+height);
while ( targetPTR < targetLimitPTR )
{
while (targetPTR < targetLineLimitPTR)
{
//fprintf(stderr,"Reading Triplet sourcePTR %p targetPTR is %p\n",sourcePTR ,targetPTR);
*targetPTR = R; ++targetPTR;
*targetPTR = G; ++targetPTR;
*targetPTR = B; ++targetPTR;
}
targetLineLimitPTR += targetWidth*3;
targetPTR+=targetLineSkip;
}
return 1;
}
int bitbltRGBBothDirections(unsigned char * target, unsigned int tX, unsigned int tY , unsigned int targetWidth , unsigned int targetHeight ,
unsigned char * source , unsigned int sX, unsigned int sY , unsigned int sourceWidth , unsigned int sourceHeight ,
unsigned int width , unsigned int height)
{
if ( (target==0)||(source==0) ) { return 0; }
if ( (width==0)&&(height==0) ) { return 0; }
if ( (sourceWidth==0)&&(sourceHeight==0) ) { return 0; }
fprintf(stderr,"BitBlt an area of target image %u,%u sized %u,%u \n",tX,tY,targetWidth,targetHeight);
fprintf(stderr,"BitBlt an area of source image %u,%u sized %u,%u \n",sX,sY,sourceWidth,sourceHeight);
fprintf(stderr,"BitBlt size was width %u height %u \n",width,height);
//Check for bounds -----------------------------------------
if (tX+width>=targetWidth) { width=targetWidth-tX-1; }
if (tY+height>=targetHeight) { height=targetHeight-tY-1; }
if (sX+width>=sourceWidth) { width=sourceWidth-sX-1; }
if (sY+height>=sourceHeight) { height=sourceHeight-sY-1; }
//----------------------------------------------------------
fprintf(stderr,"BitBlt size NOW is width %u height %u \n",width,height);
if ( (width==0) || (height==0) ) { fprintf(stderr,"Unacceptable size..\n"); return 0;}
if ( (width>sourceWidth) || (width>targetWidth) ) { fprintf(stderr,"Unacceptable size , too big..\n"); return 0;}
if ( (height>sourceHeight) || (height>targetHeight) ) { fprintf(stderr,"Unacceptable size , too big..\n"); return 0;}
unsigned char * sourcePTR = source+ MEMPLACE3(sX,sY,sourceWidth);
unsigned char * sourceLimitPTR = source+ MEMPLACE3((sX+width),(sY+height),sourceWidth);
unsigned int sourceLineSkip = (sourceWidth-width) * 3;
unsigned char * sourceLineLimitPTR = sourcePTR + (width*3) -3; /*-3 is required here*/
//fprintf(stderr,"SOURCE (RGB size %u/%u) Starts at %u,%u and ends at %u,%u\n",sourceWidth,sourceHeight,sX,sY,sX+width,sY+height);
//fprintf(stderr,"sourcePTR is %p , limit is %p \n",sourcePTR,sourceLimitPTR);
//fprintf(stderr,"sourceLineSkip is %u\n", sourceLineSkip);
//fprintf(stderr,"sourceLineLimitPTR is %p\n",sourceLineLimitPTR);
unsigned char * targetPTR = target + MEMPLACE3(tX,tY,targetWidth);
unsigned char * targetLimitPTR = target + MEMPLACE3((tX+width),(tY+height),targetWidth);
unsigned int targetLineSkip = (targetWidth-width) * 3;
unsigned char * targetLineLimitPTR = targetPTR + (width*3) -3; /*-3 is required here*/
//fprintf(stderr,"TARGET (RGB size %u/%u) Starts at %u,%u and ends at %u,%u\n",targetWidth,targetHeight,tX,tY,tX+width,tY+height);
//fprintf(stderr,"targetPTR is %p , limit is %p \n",targetPTR,targetLimitPTR);
//fprintf(stderr,"targetLineSkip is %u\n", targetLineSkip);
//fprintf(stderr,"targetLineLimitPTR is %p\n",targetLineLimitPTR);
while ( (sourcePTR < sourceLimitPTR) && ( targetPTR+3 < targetLimitPTR ) )
{
while ( (sourcePTR < sourceLineLimitPTR) && ((targetPTR+3 < targetLineLimitPTR)) )
{
//fprintf(stderr,"Reading Triplet sourcePTR %p targetPTR is %p\n",sourcePTR ,targetPTR);
*targetPTR = *sourcePTR; ++targetPTR; ++sourcePTR;
*targetPTR = *sourcePTR; ++targetPTR; ++sourcePTR;
*targetPTR = *sourcePTR; ++targetPTR; ++sourcePTR;
}
sourceLineLimitPTR += sourceWidth*3;
targetLineLimitPTR += targetWidth*3;
sourcePTR+=sourceLineSkip;
targetPTR+=targetLineSkip;
}
return 1;
}
int mixbltRGB(unsigned char * target, unsigned int tX, unsigned int tY , unsigned int targetWidth , unsigned int targetHeight ,
unsigned char * source , unsigned int sX, unsigned int sY , unsigned int sourceWidth , unsigned int sourceHeight ,
unsigned int width , unsigned int height)
{
if ( (target==0)||(source==0) ) { return 0; }
if ( (width==0)&&(height==0) ) { return 0; }
if ( (sourceWidth==0)&&(sourceHeight==0) ) { return 0; }
//Check for bounds -----------------------------------------
if (tX+width>=targetWidth) { width=targetWidth-tX-1; }
if (tY+height>=targetHeight) { height=targetHeight-tY-1; }
if (sX+width>=sourceWidth) { width=sourceWidth-sX-1; }
if (sY+height>=sourceHeight) { height=sourceHeight-sY-1; }
//----------------------------------------------------------
unsigned char * sourcePTR; unsigned char * sourceLineLimitPTR; unsigned char * sourceLimitPTR; unsigned int sourceLineSkip;
unsigned char * targetPTR; /*unsigned char * targetLimitPTR;*/ unsigned int targetLineSkip;
sourcePTR = source+ MEMPLACE3(sX,sY,sourceWidth);
sourceLimitPTR = source+ MEMPLACE3((sX+width),(sY+height),sourceWidth);
sourceLineSkip = (sourceWidth-width) * 3;
sourceLineLimitPTR = sourcePTR + (width*3);
fprintf(stderr,"SOURCE (RGB %u/%u) Starts at %u,%u and ends at %u,%u\n",sourceWidth,sourceHeight,sX,sY,sX+width,sY+height);
targetPTR = target + MEMPLACE3(tX,tY,targetWidth);
//targetLimitPTR = target + MEMPLACE3((tX+width),(tY+height),targetWidth);
targetLineSkip = (targetWidth-width) * 3;
fprintf(stderr,"TARGET (RGB %u/%u) Starts at %u,%u and ends at %u,%u\n",targetWidth,targetHeight,tX,tY,tX+width,tY+height);
unsigned int color = 0;
while (sourcePTR < sourceLimitPTR)
{
while (sourcePTR < sourceLineLimitPTR)
{
if (*sourcePTR==0) { color = *targetPTR; } else { color = (unsigned int) ( *targetPTR + *sourcePTR ) / 2; }
*targetPTR = (unsigned char ) color;
++targetPTR; ++sourcePTR;
if (*sourcePTR==0) { color = *targetPTR; } else { color = (unsigned int) ( *targetPTR + *sourcePTR ) / 2; }
*targetPTR = (unsigned char ) color;
++targetPTR; ++sourcePTR;
if (*sourcePTR==0) { color = *targetPTR; } else { color = (unsigned int) ( *targetPTR + *sourcePTR ) / 2; }
*targetPTR = (unsigned char ) color;
++targetPTR; ++sourcePTR;
}
sourceLineLimitPTR+= sourceWidth*3;//*3;
targetPTR+=targetLineSkip;
sourcePTR+=sourceLineSkip;
}
return 1;
}
/*
BITBLT , etc
*/
void CopyPartOfImageToImage(unsigned char * input_img,unsigned char * output_img,unsigned int px,unsigned int py,unsigned int tx,unsigned int ty,unsigned int size_x,unsigned int size_y)
{
register unsigned char *input_pointer,*input_pointer_startline,*input_pointer_endline,*input_pointer_stop;
register unsigned char *output_pointer,*output_pointer_startline,*output_pointer_stop;
if (px>=metrics[RESOLUTION_X]) { fprintf(stderr,"CopyPartOfImageToImage : Source X out of bounds\n"); return; }
if (px+size_x>=metrics[RESOLUTION_X]) { fprintf(stderr,"CopyPartOfImageToImage : Source X Size out of bounds\n");
size_x=metrics[RESOLUTION_X]-px;}
if (py>=metrics[RESOLUTION_Y]) { fprintf(stderr,"CopyPartOfImageToImage : Source Y out of bounds\n"); return; }
if (py+size_y>=metrics[RESOLUTION_Y]) { fprintf(stderr,"CopyPartOfImageToImage : Source Y Size out of bounds\n");
size_y=metrics[RESOLUTION_Y]-py;}
if (tx>=metrics[RESOLUTION_X]) { fprintf(stderr,"CopyPartOfImageToImage : Target X out of bounds\n"); return; }
if (tx+size_x>=metrics[RESOLUTION_X]) { fprintf(stderr,"CopyPartOfImageToImage : Target X Size out of bounds\n");
size_x=metrics[RESOLUTION_X]-tx;}
if (ty>=metrics[RESOLUTION_Y]) { fprintf(stderr,"CopyPartOfImageToImage : Target Y out of bounds\n"); return; }
if (ty+size_y>=metrics[RESOLUTION_Y]) { fprintf(stderr,"CopyPartOfImageToImage : Target Y Size out of bounds\n");
size_y=metrics[RESOLUTION_Y]-ty;}
unsigned int line_size =size_x * 3;
input_pointer=(BYTE *) input_img+ MEMPLACE3(px,py,metrics[RESOLUTION_X]);
input_pointer_startline=input_pointer;
input_pointer_endline=input_pointer_startline+line_size;
input_pointer_stop=(BYTE *) input_img+ MEMPLACE3(px+size_x,py+size_y,metrics[RESOLUTION_X]);
output_pointer=(BYTE *) output_img+ MEMPLACE3(tx,ty,metrics[RESOLUTION_X]);
output_pointer_startline=output_pointer;
output_pointer_stop=(BYTE *) output_img+ MEMPLACE3(tx+size_x,ty+size_y,metrics[RESOLUTION_X]);
register unsigned char *r,*g,*b;
while ( (input_pointer<input_pointer_stop) && (input_pointer<input_pointer_stop) && (output_pointer<output_pointer_stop) )
{
while (input_pointer<input_pointer_endline)
{
r=(unsigned char*) input_pointer++; *output_pointer = *r; ++output_pointer;
g=(unsigned char*) input_pointer++; *output_pointer = *g; ++output_pointer;
b=(unsigned char*) input_pointer++; *output_pointer = *b; ++output_pointer;
}
input_pointer_startline+=metrics[RESOLUTION_X_3_BYTE];
input_pointer_endline=input_pointer_startline+line_size;
input_pointer=input_pointer_startline;
output_pointer_startline+=metrics[RESOLUTION_X_3_BYTE];
output_pointer=output_pointer_startline;
}
}
int calculateHistogram(unsigned char * target, unsigned int tX, unsigned int tY , unsigned int targetWidth , unsigned int targetHeight ,
unsigned int * RHistogram , unsigned int * GHistogram , unsigned int * BHistogram , unsigned int * samples ,
unsigned int width , unsigned int height)
{
if ( (RHistogram==0)||(GHistogram==0)||(BHistogram==0) )
{
fprintf(stderr,"Cannot Calculate Histogram without a target histogram output");
return 0;
}
*samples=0;
memset(RHistogram,0,255);
memset(GHistogram,0,255);
memset(BHistogram,0,255);
fprintf(stderr,"Initially a Histogram at an area (%u,%u) of target image starting at %u,%u sized %u,%u \n",width,height,tX,tY,targetWidth,targetHeight);
//Check for bounds -----------------------------------------
if (tX+width>=targetWidth) { width=targetWidth-tX-1; }
if (tY+height>=targetHeight) { height=targetHeight-tY-1; }
//----------------------------------------------------------
unsigned char * targetPTR; unsigned char * targetLineLimitPTR; unsigned char * targetLimitPTR; unsigned int targetLineSkip;
targetPTR = target + MEMPLACE3(tX,tY,targetWidth);
targetLimitPTR = target + MEMPLACE3((tX+width),(tY+height),targetWidth);
targetLineSkip = (targetWidth-width) * 3;
targetLineLimitPTR = targetPTR + (width*3) -3; /*-3 is required here*/
fprintf(stderr,"Calculating a Histogram at an area (%u,%u) of target image starting at %u,%u sized %u,%u \n",width,height,tX,tY,targetWidth,targetHeight);
while ( targetPTR < targetLimitPTR )
{
while (targetPTR < targetLineLimitPTR)
{
//fprintf(stderr,"Reading Triplet sourcePTR %p targetPTR is %p\n",sourcePTR ,targetPTR);
RHistogram[*targetPTR]+=1; ++targetPTR;
GHistogram[*targetPTR]+=1; ++targetPTR;
BHistogram[*targetPTR]+=1; ++targetPTR;
}
targetLineLimitPTR += targetWidth*3;
targetPTR+=targetLineSkip;
}
fprintf(stderr,"Done\n");
*samples=targetWidth*targetHeight;
return 1;
}
int getRGBPixel(unsigned char * ptrRGB , unsigned int RGBwidth , unsigned int RGBheight , unsigned int x , unsigned int y , unsigned char * R , unsigned char * G , unsigned char * B)
{
unsigned char * ptr = ptrRGB + MEMPLACE3(x,y,RGBwidth);
*R = *ptr; ++ptr;
*G = *ptr; ++ptr;
*B = *ptr; ++ptr;
return 1;
}
