Johnny Cheng
Brian Cheung
Austin Wong
Electrical Engineering 113D Project
Professor Rajeev Jain
TA Rick Lan
Abstract
We implemented a general technique for “colorizing” grayscale image by transferring color between a source, color image and a destination, grayscale image. Traditionally, relatively significant human labor is required for this procedure such as choosing RGB colors from a palette to color individual components. In an effort to minimize labor, this concept involves transferring the entire color or “mood” from the source to the target image by matching luminance and texture information between the images. In theory, one can do a luminance comparison and transfer the chromaticity information of the colored image or a chromaticity comparison and transfer the luminance values. We chose to do the former and transfer only chromaticity while retaining the original luminance values of the target image.
Introduction
The benefits of being able to add color to grayscale images are tremendous. By adding color, one can greatly enhance the visual appearance and utilization of grayscale images. For example, adding color to an old black and white image has great appeal to Photoshop applications and adding color to xray images and scientific illustrations can perceptually enhance the information content of the image.
Traditional colored images are a composition of threedimensional (RGB) pixel values. For the task of “colorizing” a grayscale image, we first assigned the threedimensional (RGB) pixel values to an image that varied only along one dimension. To achieve this task, we utilized the color space YCbCr, where Y represents the luminance components and Cb and Cr represent the chromaticity components. The beauty of this color space is that it allows us to “color” the image by keeping one value constant while transferring the other dimensions. This idea is the basis of the whole “colorization” technique.
Once the threedimensional (RGB) pixel values were transformed into twodimensional (YCbCr) values, we proceeded to do a comparison between the source color image and the destination grayscale image. With both images in the YCbCr format, we could choose to keep either the Y (luminance) or the CbCr (chromaticity) constant and transfer the information of the source color image onto the destination grayscale image. For simplicity, we decided to keep the luminance values constant and do a comparison on this single dimension rather than keeping and doing the comparison with the chromaticity, whose information is carried in two dimensions (Cb and Cr).
While doing the luminance comparison, we transferred the chromaticity information of the best matching values to the constant luminance values. By keeping the luminance values constant, we ensured that the image was not distorted from its previous form. Upon doing this, the grayscale image was now technically “colored”. However one last step was required.
The last step involved converting the newly “colored” YCbCr grayscale image back into the threedimensional RGB pixel value form and this was the portion our group implemented on the Texas Instruments’ TMS320C54x DSP chip under the guidance and suggestion of the TA, Rick. Due to the large scope of the project and the limited time, we had to plan our goals accordingly. Regardless, with the YCbCr coefficients of the colored grayscale image generated by the gray2rgb.m file, we needed to carry out the following functions for conversion.
R´ = 1.164(Y  16) + 1.596(Cr  128)
G´ = 1.164(Y  16)  0.813(Cr  128)  0.392(Cb  128)
B´ = 1.164(Y  16) + 2.017(Cb  128)
Procedures
Preparing the Images:
We initially took 2 similar 162x210 images, one in RGB format and the other in grayscale, and decreased the resolutions to two 8x10 images using Photoshop. At this resolution, the picture was indiscernible, but the colors were apparent. Thus, the goal of the experiment, which was to color a grayscale image, can still be attained at such a resolution.
Using Matlab, we used the imread command to read in the coefficients of each image. The RGB image created an 8x10x3 matrix of coefficients whereas the grayscale image created an 8x10x1 matrix of coefficients. The gray2rgb.m file was first used to convert the RGB image into an YCbCr image. Then, we used the program to perform a luminance comparison between the two image files; the theory for the luminance comparison is mentioned in the introduction. Matlab then created a new 8x10 YCbCr matrix that referenced the colors from the RGB image into the grayscale image. From this format, we implemented the assembly language code to change this back into RGB format.
Assembly Programming:
As mentioned earlier, we took the 8x10 YCbCr matrix of coefficients and converted it into an RGB image. To do this, we used three algebraic equations:
R´ = 1.164(Y  16) + 1.596(Cr  128)
G´ = 1.164(Y  16)  0.813(Cr  128)  0.392(Cb  128)
B´ = 1.164(Y  16) + 2.017(Cb  128).
The constant values, due to limitations from the DSP chip, were multiplied by 100 and rounded. As a result, the new equations that we implemented in assembly language are:
R´ = 116(Y  16) + 160(Cr  128)
G´ = 116(Y  16)  81(Cr  128)  39(Cb  128)
B´ = 116(Y  16) + 202(Cb  128).
The Y, Cr, and Cb conversion coefficients were taken from Matlab. From these values, we are able to recreate an 8x10x3 matrix that would represent the RGB file.
From a syntax standpoint, we made use of 8 registers and two large blocks of memory in order to fully implement these algebraic equations. Primarily, we used the MACP function from the DSP chip, which multiplied two numbers and added it to the accumulator. From the 3 equations above, much of the algebra needed involves multiplying and adding. The subtraction within the parenthesis was done using a memory location, a register, and a variable, B. We would read the coefficient value into a variable called B, then subtract from it the constant value. Then we would store a memory location signified as operand into AR7. Finally, we would store B into that memory location. The syntax to perform this block of algebra is shown below.
A = #0
B = *AR1+
B = B  #16
AR7 = #operand1
*AR7 = B
MACP(*AR7,const1,A)
Within our program, each loop would represent a single equation that would give us the red, green, and blue layers in the RGB matrix of coefficients.
Output:
Now that we have our RGB matrix of coefficients, we compiled the code using dskplasm.exe within dos. After, we used Code Explorer to run the program and see the outputted matrix, which would start at the memory location 0x800. Once we obtained the coefficient values inside the memory, we exported the data onto a dat file, where the values were in hexadecimal format. The values were then copied onto an excel spreadsheet and were converted back into decimal form. From this point, we also inputted the coefficients provided by Matlab and compared them to the experimental coefficients from the DSP chip.
In addition, we also visually compared the two sets of data that we received from Matlab and the DSP chip. After obtaining the coefficients from both sources, we inputted these coefficients into Matlab and used the imshow function in Matlab to display the images. Although we expect the coefficient values to be different due to minor rounding errors from scaling, the two coefficient value sets should be close enough so that the naked eye would not be able to distinguish the two when displayed as an image file on Matlab.
Results
The following are select sample results comparing the difference between what was simulated on Matlab and the DSP. We show only the first 10 coefficients in each of the red, green and blue dimensions samples because for an image of 8x10, there are already 240 coefficients which would be lengthy and redundant to show. However, the total relative difference is calculated from all the 240 coefficients.
Red:
Scaled DSP HEX Values

Scaled DSP Dec Values

Unscaled DSP Dec Values

UnScaled Matlab Values

Scaled Matlab values

Difference

relative difference

% relative difference

1614

5652

56.52

57

5700

48

0.008421053

0.842105263

1CB4

7348

73.48

74

7400

52

0.007027027

0.702702703

2F74

12148

121.48

122

12200

52

0.004262295

0.426229508

39A8

14760

147.6

148

14800

40

0.002702703

0.27027027

2BFC

11260

112.6

113

11300

40

0.003539823

0.353982301

39A8

14760

147.6

148

14800

40

0.002702703

0.27027027

2BB8

11192

111.92

112

11200

8

0.000714286

0.071428571

2478

9336

93.36

94

9400

64

0.006808511

0.680851064

1EDC

7900

79

79

7900

0

0

0

19B4

6580

65.8

66

6600

20

0.003030303

0.303030303

Green:
Scaled DSP HEX Values

Scaled DSP Dec Values

Unscaled DSP Dec Values

UnScaled Matlab Values

Scaled Matlab values

Difference

relative difference

% relative difference

1DDC

7644

76.44

77

7700

56

0.007272727

0.727272727

2546

9542

95.42

96

9600

58

0.006041667

0.604166667

378A

14218

142.18

143

14300

82

0.005734266

0.573426573

3.00E+48

15944

159.44

160

16000

56

0.0035

0.35

3C08

15368

153.68

154

15400

32

0.002077922

0.207792208

3.00E+48

15944

159.44

160

16000

56

0.0035

0.35

308D

12429

124.29

125

12500

71

0.00568

0.568

2974

10612

106.12

107

10700

88

0.008224299

0.822429907

24A2

9378

93.78

94

9400

22

0.002340426

0.234042553

21CA

8650

86.5

87

8700

50

0.005747126

0.574712644

Blue:
Scaled DSP HEX Values

Scaled DSP Dec Values

Unscaled DSP Dec Values

UnScaled Matlab Values

Scaled Matlab values

Difference

relative difference

% relative difference

0EC8

3784

37.84

38

3800

16

0.004210526

0.421052632

16D2

5842

58.42

59

5900

58

0.009830508

0.983050847

2694

9876

98.76

99

9900

24

0.002424242

0.242424242

2CB4

11444

114.44

115

11500

56

0.004869565

0.486956522

2062

8290

82.9

83

8300

10

0.001204819

0.120481928

2CB4

11444

114.44

115

11500

56

0.004869565

0.486956522

28B2

10418

104.18

105

10500

82

0.007809524

0.780952381

20A8

8360

83.6

84

8400

40

0.004761905

0.476190476

1C76

7286

72.86

73

7300

14

0.001917808

0.191780822

10D4

4308

43.08

43

4300

8

0.001860465

0.186046512

Total Average Error: 0.516981113%
From numerical analysis, we can see that the total average relative difference is less than 1% which confirms that the design coding algorithms were implemented correctly on the DSP chip. The small percentages of errors are inherent in the capabilities of the DSP due to the scaling process because of the inability of the DSP to store noninteger numbers. When choosing the scaling coefficients, the larger factors will yield more accuracy, but due to memory limitations, we chose the scaling factor of 100 which still give accurate results less than 1% in errors.
The resulting “colored” image confirms that the process has been successful.
From Matlab:
+ =
Reduced 8x10 pixel versions:
+ =
From DSP:
+ =
Problems Encountered
Throughout our project, we experienced many obstacles ranging from understanding the Matlab code to implementing and debugging the DSP code.
During the initial phases of our project, we had a difficult time understanding the Matlab source code we obtained from the internet. Before using the code and making any changes to it, we first had to figure out which lines of coding were pertinent to our project. In the process of breaking down the Matlab code, although arduous at times, we obtained a better understanding of the theoretical background and its application at a coding level. For example, the overall goal of our project was to do a luminance comparison and transfer the chromaticity values, thus we needed to find exactly which line executed various equations and comparisons and then store those coefficients to be transferred.
Our initial plans were to use a color and grayscale image each of size 162 x 210. However, this proved to be problematic, since the amount of time to execute the Matlab code on the two images exceeded one minute. Keeping in mind the DSP memory constraints, we used Photoshop to shrink the two images to a more reasonable size in order to reduce the execution time. After experimenting with different image sizes, we decided to make each image 8 x 10. This in turn reduced the execution time to less than 10 seconds.
After establishing a working and efficient Matlab code, our next obstacle occurred with finding relatable assembly code, either from experiments 46 or from previous projects. Realizing that none of the previous projects have done an experiment such as ours, we decided to resort back to the fundamental assembly code we used in Experiment A. Our initial project goal was to do a luminescence comparison, but given the amount of time and complexity of implementing a sorting algorithm on the DSP chip, we instead decided to reevaluate our project specifications and choose a more feasible task given the amount of time. We instead chose to use the luminance and chromaticity values of the colored gray scale image and hard code them into the DSP chip which would then be converted to give us the three dimensional RGB pixel values.
Implementing and debugging our assembly code proved to be the most time consuming and challenging part of the project. Not being fully adept in the assembly code language, we had a hard time writing code for simple subtraction operations. After consulting with our TA, Rick Lan, we were able to implement all of our algebraic equations successfully. However, when actually executing those equations, we received many unexpected errors. The final values obtained from the RGB equations were in fact two times greater than our theoretically calculated values. Some debugging techniques we utilized included inserting flags in our code to make sure certain parts of our code was being executed, double checked the syntax and correct order of operations in our algebraic equations, and looked at the actual values stored in our registers and memory to see if each operation was properly executed, stored, and carried through. After doing all this, there was still no remedy to our problem, since our syntax and equations were all correct. However, unexpectedly, our DSP chip crashed and forced us to restart Code Explorer. Surprisingly, this fixed our problem and our theoretical values matched now coincided with our values obtained from the DSP chip.
Some other minor problems that occurred during the implementation and debugging of our code included: not initializing the correct number of .data values and not copying all the coefficients from Matlab to the DSP chip, which were all careless mistakes on our part which were easily detected and corrected.
Conclusion
As previously mentioned in the introduction, the benefits of coloring a grayscale image are enormous. Through the use of colors, images are not only visually enhanced, but the colors can actually enhance the information contents as well. Numerous applications can be derived from this process that ranges from Photoshop applications to coloring xray and scientific illustrations. In an effort to minimize the amount of human labor in this process, we explore the idea based on the paper "Transferring Color to greyscale Images" by Tomihisa Welsh et. al. and utilize the open source Matlab implementations of Jeny Rajan and Chandrashekar P.S. Through the use of luminance comparison, we were able to somewhat achieve this means.
As the scope of this “colorization” process is rather large, we chose to implement only the last portion of the Matlab file onto the DSP chip under the guidance and suggestion of the TA. By carrying out the YCbCr conversion to RGB on the DSP, we have utilized everything we have learned in this class. As the data suggests, the extreme precision of the data points from the low relative errors indicates that the coding algorithms were implemented correctly. We leave the implementations of the other processes as possible projects for future EE113D students.
Code
gray2rgb.m:
function R=gray2rgb(img1,img2)
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%The Matlab gray2rgb.m file converts a gray image to color image based on a %
%color image submitted along with the input gray image. Using a luminance %
%comparison between the gray and RGB (colored) image, color is actually %
%transferred onto the grayscale image on the YCbCr color space. Naturally, %
%the better the source YCbCr color space image match to the destination %
%gray image, the better the RGB color space coloring will be. %
% %
%The Matlab implementation is based on the paper "Transferring Color to %
%greyscale Images" by Tomihisa Welsh et. al. %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% img1  Source Image (gray image) img2  Selected color image for
% coloring the gray image.
tic
clc;
warning off;
imt=imread(img1);
ims=imread(img2);
[sx sy sz]=size(imt);
[tx ty tz]=size(ims);
if sz~=1
imt=rgb2gray(imt);
end
if tz~=3
disp ('img2 must be a color image (not indexed)');
else
imt(:,:,2)=imt(:,:,1);
imt(:,:,3)=imt(:,:,1);
% Converting to ycbcr color space
nspace1=rgb2ycbcr(ims);
nspace2= rgb2ycbcr(imt);
ms=double(nspace1(:,:,1));
mt=double(nspace2(:,:,1));
m1=max(max(ms));
m2=min(min(ms));
m3=max(max(mt));
m4=min(min(mt));
d1=m1m2;
d2=m3m4;
% Normalization
dx1=ms;
dx2=mt;
dx1=(dx1*255)/(255d1);
dx2=(dx2*255)/(255d2);
[mx,my,mz]=size(dx2);
%Luminance Comparison
disp('Please wait..................');
for i=1:mx
for j=1:my
iy=dx2(i,j);
tmp=abs(dx1iy);
ck=min(min(tmp));
[r,c] = find(tmp==ck);
ck=isempty(r);
if (ck~=1)
nimage(i,j,2)=nspace1(r(1),c(1),2);
nimage(i,j,3)=nspace1(r(1),c(1),3);
nimage(i,j,1)=nspace2(i,j,1);
end
end
end
rslt=ycbcr2rgb(nimage)
figure,imshow(uint8(imt));
figure,imshow(uint8(rslt));
R=uint8(rslt);
toc
end
DSP.asm:
;***************************************************************************;
;EE113D  Spring 2006 ;
;Professor Jain ;
;TA Rick Lan ;
; ;
;Project Description: Our file converts a YCbCr image to a RGB image. ;
;It will read in a luminescent matrix from Matlab and then perform ;
;3 algebraic equations to change a grayscale image (2D image) into a ;
;colored image (3D matrix). The three equations we will be implementing ;
;are: R´ = 1.164(Y  16) + 1.596(Cr  128) ;
;G´ = 1.164(Y  16)  0.813(Cr  128)  0.392(Cb  128) ;
;B´ = 1.164(Y  16) + 2.017(Cb  128). ;
; ;
;Written by: Austin Wong ;
; Johnny Cheng ;
; Brian Cheung ;
;***************************************************************************;
.setsect ".text", 0x500,0 ;Executible code in ".text"
;section will begin at 0x500
;in program memory
.setsect ".data", 0x800,1 ;Numbers to be sorted will
;begin at 0x800 in data memory
.data ;Data section begins
const1 .word 116 ;The orginal multiplying constants
const2 .word 160 ;are 1.164, 1.596, 0.813, 0.392, and 2.017
const3 .word 81 ;multiple these constants by 100 and rounded
const4 .word 39 ;since there is not enough memory to keep the constants in 3 digits.
const5 .word 202
operand1 .word 0 ;Operand variables used to store intermediate values during execution
operand2 .word 0
;Below are the Y, Cb, and Cr conversion constants
y .word 73, 89, 129, 146, 131, 146, 118, 102, 91, 81, 58, 70, 96, 139, 140, 102, 65, 80, 102, 111, 62, 65, 88, 140, 122, 62, 75, 114, 133, 125, 83, 98, 80, 107, 117, 67, 89, 123, 124, 98, 93, 116, 93, 117, 141, 93, 88, 77, 74, 64, 66, 83, 90, 122, 122, 82, 88, 73, 68, 55, 133, 137, 127, 133, 124, 84, 86, 104, 109, 84, 141, 126, 134, 150, 129, 103, 100, 101, 107, 95
Cb .word 114, 115, 112, 110, 103, 110, 121, 120, 121, 112, 123, 114, 111, 130, 130, 120, 114, 114, 120, 103, 114, 114, 115, 130, 121, 114, 112, 111, 84, 108, 115, 111, 114, 103, 111, 119, 115, 108, 108, 111, 117, 111, 117, 111, 84, 117, 115, 122, 114, 114, 119, 115, 119, 121, 121, 115, 115, 114, 119, 123, 84, 130, 110, 84, 108, 115, 115, 119, 103, 115, 84, 99, 84, 111, 112, 120, 120, 120, 103, 111
Cr .word 122, 121, 122, 126, 115, 126, 124, 124, 123, 122, 122, 122, 119, 123, 123, 124, 122, 121, 124, 117, 122, 122, 121, 123, 124, 122, 120, 121, 126, 124, 121, 123, 121, 117, 121, 122, 121, 124, 124, 123, 120, 121, 120, 121, 123, 120, 121, 123, 122, 122, 122, 121, 123, 124, 124, 121, 121, 122, 122, 122, 126, 123, 117, 126, 124, 121, 122, 123, 117, 121, 123, 119, 126, 123, 122, 124, 124, 124, 117, 119
;Below is the allocated memory for the output 3D matrix (8x10x3).
;Output1, output2, and output3 represent different layers in the same matrix
output1 .word 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
output2 .word 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
output3 .word 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
.text ;Executable code section begins.
count .set 79 ;We will be working with an 8x10 matrix so we will set the counter to 79 performing 80 executions
AR0 = #count ;AR0 will hold the count number
AR1 = #y ;AR1 will hold the address to the y conversion constants
AR2 = #Cb ;AR2 will hold the address to the Cb conversion constants
AR3 = #Cr ;AR3 will hold the address to the Cr conversion constants
AR4 = #output1 ;AR4 will hold the address to the first layer of the output matrix
AR5 = #output2 ;AR5 will hold the address to the second layer of the output matrix
AR6 = #output3 ;AR6 will hold the address to the third layer of the output matrix
nop
loop1 ;This loop will perform the equation: R´ = 1.164(Y  16) + 1.596(Cr  128) and store it into output1
A = #0 ;Clears the accumulator
B = *AR1+ ;This section will perform the expression, (Y16), and store the value into B
B = B  #16
AR7 = #operand1 ;AR7 will hold the address location of operand1, which will hold the value of B
nop
*AR7 = B
nop
nop
MACP(*AR7,const1,A) ;This will multiply B to const1 (116) and add it the value stored in the accumulator
B = *AR3+ ;This will increment the Cr conversion constant matrix
B = B  #128 ;This section will perform the expression, 1.596(Cr  128)
AR7 = #operand2 ;AR7 will hold the address location of operand2, which will hold the value of B
nop
*AR7 = B
nop
MACP(*AR7,const2,A) ;This will multiply B to const2 (160) and add it the value stored in the accumulator
*AR4+ = A ;Set accumulator A to output1, AR4, and then increment AR4
if (*AR0 != 0) goto loop1 ;If the count is not at 0, go back to loop1 and decrement the count
nop
AR0 = #count ;Reinitialize the register values for the next algebraic equation
AR1 = #y
AR2 = #Cb
AR3 = #Cr
loop2 ;This loop will perform the equation: G´ = 1.164(Y  16)  0.813(Cr  128)  0.392(Cb  128)
;and store it into output2
A = #0 ;Clears the accumulator
B = *AR1+
B = B  #16 ;This section will perform the expression, (Y16), and store the value into B
AR7 = #operand1 ;AR7 will hold the address location of operand1, which will hold the value of B
nop
*AR7 = B
nop
nop
MACP(*AR7,const1,A) ;This will multiply B to const1 (116) and add it the value stored in the accumulator
B = *AR3+ ;This will increment the Cr conversion constant matrix
B = B  #128 ;This section will perform the expression, 0.813(Cr  128)
AR7 = #operand1
nop
*AR7 = B
nop
MACP(*AR7,const3,A) ;This will multiply B to const3 (81) and add it the value stored in the accumulator
B = *AR2+ ;This will increment the Cb conversion constant matrix
B = B  #128 ;This section will perform the expression,  0.392(Cb  128)
AR7 = #operand1
nop
*AR7 = B
nop
MACP(*AR7,const4,A) ;This will multiply B to const4 (39) and add it the value stored in the accumulator
*AR5+ = A ;Set accumulator A to output2, AR5, and increment AR5
if (*AR0 != 0) goto loop2 ;If the count is not at 0, go back to loop1 and decrement the count
AR0 = #count ;Reinitialize the register values for the next algebraic equation
AR1 = #y
AR2 = #Cb
AR3 = #Cr
loop3
A = #0 ;Clears the accumulator
B = *AR1+ ;This section will perform the expression, (Y16), and store the value into B
B = B  #16
AR7 = #operand1
nop
*AR7 = B
nop
nop
MACP(*AR7,const1,A) ;This will multiply B to const1 (116) and add it the value stored in the accumulator
B = *AR2+ ;This section will perform the expression, (Cb128), and store the value into B
B = B  #128
AR7 = #operand1
nop
*AR7 = B
nop
MACP(*AR7,const5,A) ;This will multiply B to const5 (202) and add it the value stored in the accumulator
*AR6+ = A ;Set accumulator A to output3, AR6, and increment AR6
if (*AR0 != 0) goto loop3 ;If the count is not at 0, go back to loop1 and decrement the count
nop
stop nop
goto stop ;infinite loop
.end
References
[1] T. Welsh, “Transferring Color To Greyscale Images,” [Online Documentation], 2006 May 15, Available HTTP: http://www.cs.sunysb.edu/~tfwelsh/colorize/
[2] J. Rajan, “Gray Image to Color Image Conversion,” [Online Documentation], 2006 May 15,
Available HTTP: http://www.mathworks.com/matlabcentral/fileexchange/loadFile.do?objectId=8214
[3] Wikipedia, “YCbCr,” [Online Documentation], 2006 May 15,
Available HTTP: http://en.wikipedia.org/wiki/YCbCr
[4] K. Jack, “YCbCr to RGB Considerations,” [Online Documentation], 2006 May 15,
Available HTTP: http://www.intersil.com/data/an/an9717.pdf
Поделитесь с Вашими друзьями: 