I would use HSV color space
it’s better to detect colors (more similar to human perception) that should help a lot. You can also use the HSV histogram to determine how many different colors you have.
If you still want to use RGB, otherwise compare
You have pen color0=(r0,g0,b0) and pixel color=(r,g,b) , so you can calculate the distance between them:
d=((r-r0)*(r-r0))+((g-g0)*(g-g0))+((b-b0)*(b-b0))
No need for sqrt . Now you just calculate d for each color that you have (pens) and select the smallest d ... You can also use the less accurate:
d=abs(r-r0)+abs(g-g0)+abs(b-b0)
If you don’t know the colors before and don’t want to use histograms
- create a color chart (re) (a set of different visible colors that you set for each new pen found).
- create an empty list of colors found
- process all pixels of the input image
- calculate distance
d to all colors found in the list - if
d less than some treshold constant, the pixels belong to this color in the list of colors found. Else add it as the new color found. - repainting pixel with color from the repeater table.
This eliminates color distortion and attenuation. You can also ignore the repainting table and use a color from the list of colors found. This process is color quantization .
[Edit1] After using the HSV color and repainting to find a list of colors (without a histogram), I got this result:
This shows that your image does not have the same lighting conditions (not a render, but a real photo). Thus, the normalization of illumination should improve this even more. I also use 2 cods for one color for gray and one for flowers ... to distinguish between two ... You can also determine the background color:
- number of pixels (should be much larger than the text color)
- dispersion along the image (should cover a large area with a relatively high density, evenly distributed ... The text is localized)
Here is the C ++ / VCL source for this:
backbuffer bmp; // source and target image struct _color { DWORD rgb; int h,s,v; }; // color entry in (re)color table _color ld_rgb(DWORD rgb) // just RGB -> HSV conversion { const int _b=0; const int _g=1; const int _r=2; const int _a=3; union { DWORD dd; BYTE db[4]; } c; double r,g,b,min,max,del,h,s,v,dr,dg,db; c.dd=rgb; r=c.db[_r]; r/=255.0; g=c.db[_g]; g/=255.0; b=c.db[_b]; b/=255.0; min=r; if (min>g) min=g; if(min>b) min=b; max=r; if (max<g) max=g; if(max<b) max=b; del=max-min; v=max; if (del<=0.1) { h=0; s=0; } // grayscale else{ s=del/max; dr=(((max-r)/6.0)+(del/2.0))/del; dg=(((max-g)/6.0)+(del/2.0))/del; db=(((max-b)/6.0)+(del/2.0))/del; if (fabs(r-max)<1e-10) h=db-dg; else if (fabs(g-max)<1e-10) h=(1.0/3.0)+dr-db; else if (fabs(b-max)<1e-10) h=(2.0/3.0)+dg-dr; if (h<0.0) h+=1.0; if (h>1.0) h-=1.0; } _color ccc; ccc.rgb=rgb; ccc.h=255.0*h; ccc.s=255.0*s; ccc.v=255.0*v; return ccc; } void recolor() // this is the recolor you want { // load input jpg file to bmp image TJPEGImage *jpg=new TJPEGImage(); jpg->LoadFromFile("in.jpg"); bmp.bmp->Assign(jpg); bmp.resize(bmp.bmp->Width,bmp.bmp->Height); delete jpg; // recolor bmp int i,x,y,d; _color c0,c1; List<_color> col; // color list col.num=0; // clear colro list for (y=0;y<bmp.ys;y++) // process all pixels for (x=0;x<bmp.xs;x++) { c0=ld_rgb(bmp.pyx[y][x]); // pixel color -> hsv if ((c0.h==0)&&(c0.s==0)) // compare it to found colors (grayscales) for (i=0;i<col.num;i++) { // i=-1; c1.rgb=0x00202020; break; c1=col[i]; if ((c1.h!=0)||(c1.s!=0)) continue; d=abs(c1.v-c0.v); if (d<32) { i=-1; break; } // match found ? } else // compare it to found colors for (i=0;i<col.num;i++) { // i=-1; c1.rgb=0x0000FF00; break; c1=col[i]; if ((c1.h==0)&&(c1.s==0)) continue; d=(abs(c1.h-c0.h))+(abs(c1.s-c0.s)); if (d<50) { i=-1; break; } // match found ? } if (i>=0) { c1=c0; col.add(c1); } // if not add new color bmp.pyx[y][x]=c1.rgb; // recolor; } bmp.bmp->Canvas->Brush->Style=bsClear; bmp.bmp->Canvas->Font->Color=0x00802040; bmp.bmp->Canvas->TextOutA(5,0,"Found colors: "+AnsiString(col.num)); bmp.bmp->Canvas->Brush->Style=bsSolid; for (d=16,i=0;i<col.num;i++) for (y=d;y<=d+d;y++) for (x=d*i+1;(x<d*i+d)&&(x<bmp.xs);x++) bmp.pyx[y][x]=col[i].rgb; }
List<T> l; is a dynamic array such as std::vector<T> ... represents T l[l.num];backbuffer bmp; is my image class ... bmp.bmp Holds the GDI bitmap, and bmp.xs,bmp.ys is the resolutioncol contains the colors found ...
[Edit1] bi-cubic normalization of lighting
I recently rewrote my standard DIP world illumination so that I could take a picture on your original image (as one of many test images), and here is the result (with forced (detected) blank space to Repaint):
As you can see, the middle spot of red lighting has disappeared. You can try your algorithm to see if normalizing lighting helps before you encode it (it's a bit complicated if everything is done correctly). This is done as follows:
create a grid (table) for your image
each cell contains a medium color and cumulative delta strong> (noise) cells. Also one flag tells if the cell is paper or ink . The cell size should be around <0.5 - 1.5> minimum size of the part (for example, letter or pen width ...)
set all cells with high deltas as ink, the rest as paper
- calculate the average color of all merged paper cells
each adjacent cell ink cell
set as ink if its average color is too far from the average average color of the paper. Be careful not to take these new ink cells as an adjacent condition for this step. (use the temp flag or a bit of another flag and restore it after that ...
find 16 control points evenly distributed along the image (use only paper cells)
they should be around the coordinates 0%,33%,66%,100% image resolution. Thus, bi-cubic interpolation is permissible.
for each pixel
calculate the cell color bi-cubically and name it c0 Then apply normalization to the pixel ( in RGB space !!! ):
pixel+=global_avg_color-c0 ;
This will align the color of the paper throughout the image to a very close match with global_avg_color . Leave unused parts without paper.
optionally recolor the entire area of paper cells with global_avg_color
This is not necessary, but it will save most of the noise from the background. Like paper texture ...