Downloaded 12 times
![5.3.1. Brightness and contrast modification
The contrast modification will be the coefficient by how the component will be multiply, and the
brightness will be the sum to add to the component.
float v = 0;
v = (float)(cValue + 100) / 100f;
float m = 0.5f * (1.0f ‐ v) + (float)bValue / 100f;
/// The matrix is compose of 4 lines for Red, Green, Blue parameters
/// then the line for Alpha parameter
/// and the identity line which is use to multiply the matrix
cm = new ColorMatrix(new float[][]{
new float[]{v,0,0,0,0},
new float[]{0,v,0,0,0},
new float[]{0,0,v,0,0},
new float[]{0,0,0,1,0},
new float[]{m,m,m,0,1}
});
ImageAttributes ia = new ImageAttributes();
ia.SetColorMatrix(cm);
The cValue in the previous example code represent the contrast value given on the track bar,
and the bValue the brightness value on the brightness track bar. The contrast value is translated
in a first time as a value to multiply on the color component. If the contrast value is 75, colors
component is multiply by 1.75. Then the brightness will be add. The brightness value is compute
as a number between ‐1.0 to 1.0. If the contrast is change in the same time, the value of the
contrast is taken in the algorithm. This change the brightness by the half of the difference
between the vector of the contrast to the normal contrast vector. (0.5f * (1.0f ‐ v))
5.3.2. Saturation
The color saturation is used to describe the intensity of color in an image. Most of saturated
images have overly bright color. De‐saturation of a color translates the color image into a
monochrome one. The saturation algorithm use 3 weighs value given by adobe as the luminance
value for the color. The color green is highly recognizable by human eyes, so it luminance value
is high, blue is the color that human eyes has the less perception, and red is in the middle range.
The sum of the three values makes 1. The weight must be add the value of the saturation given
Page 31](https://image.slidesharecdn.com/0912124-pierrechevillotreport-121212114524-phpapp01/75/Open-Source-adobe-lightroom-like-31-2048.jpg)
![by the track bar. Color saturation is weight and the complementary color has to be weight to.
The all matrix will be multiply.
The main component of the color is weigh by the luminance, and then the saturation vector is
apply in addition. Complementary colors are only weight by luminance vector.
float red = (float) 0.3086;
float green = (float) 0.6094;
float blue = (float) 0.0820;
float sat = (float) (satValue + 100) / 100f ;
float redSaturation = (1 ‐ sat) * red + sat;
float redSaturationComp = (1 ‐ sat) * red;
float greenSaturation = (1 ‐ sat) * green + sat;
float greenSaturationComp = (1 ‐ sat) * green;
float blueSaturation = (1 ‐ sat) * blue + sat;
float blueSaturationComp = (1 ‐ sat) * blue;
cm = new ColorMatrix(new float[][]{
new float[]{redSaturation,redSaturationComp,redSaturationComp,0,0},
new float[]{greenSaturationComp,greenSaturation,greenSaturationComp,0,0},
new float[]{blueSaturationComp,blueSaturationComp,blueSaturation,0,0},
new float[]{0,0,0,1,0},
new float[]{0,0,0,0,1}
});
5.3.3. Specific color saturation
The color filter not given the results wanted. The algorithm gives the possibility to apply a color
filter on the image.
Normally to saturate a specific color, the channel of this color has to be multiply by a vector, and
the others channel not changes. And the de‐saturation has to apply a filter where the others
colors can go through, but not the color we want to de‐saturate. The human vision is a
perception of color, if a filter is place before eyes analyze the color percepted, one color could
be remove (filter).
Page 32](https://image.slidesharecdn.com/0912124-pierrechevillotreport-121212114524-phpapp01/75/Open-Source-adobe-lightroom-like-32-2048.jpg)
![Figure 7
There are 3 filters to block primary colors:
Cyan : block Red, let Blue and Green
Yellow : block Blue, let Red and Green
Magenta : block Green, let Red and Blue
float blue = (float)0.0820;
float sat = (float)(satValue + 100) / 100f;
float blueSat = (1 ‐ sat) * blue + sat;
float bComp = (1 ‐ sat) * blue;
cm = new ColorMatrix(new float[][]{
new float[]{1,0,0,0,0},
new float[]{0,1,0,0,0},
new float[]{0,0,1,0,0},
new float[]{0,0,0,1,0},
new float[]{0,0,blueSat,0,1}
});
ImageAttributes ia = new ImageAttributes();
ia.SetColorMatrix(cm);
5.4.Histogram
One of the ways to evaluate if an image is good, is to check the histogram of the image. The
histogram will be the statistics of the intensity of the color present in the image by a graphical
way. Histogram could also be to show the brightness of a image for monochrome picture.
Drawing a histogram require to calculate some statistics as pre‐processing. A pixel stores a color
component as a value of 8bit, so the value for a color varies from 0 to 255. (28 = 256) A value of
0 in the color represents a total absence of this color, and 255, that the color reaches it
maximum intensity. The black color is the absence of any of the 3 primary component, so it will
be encode Red = 0, Green = 0, Blue = 0. And the inverse for the white, but for the color blue the
Page 33](https://image.slidesharecdn.com/0912124-pierrechevillotreport-121212114524-phpapp01/75/Open-Source-adobe-lightroom-like-33-2048.jpg)
![encoding is Red = 0, Green = 0, Blue = 255, and it is possible to make any colors by vary the bit in
each component.
The statistics will store the number of pixel which has a specific value varying from 0 to 255, in
three different set. Each set is color component storage, and the set is composing of 256 values.
The total number of pixel to archive is given by the height and width of the picture, 3456 * 5184
= 17.915.904 pixels. This number of pixel could be found by make the sum of each number
contains in the 256 values of a color.
private void calculateColor()
{
Color pix;
Bitmap bit = (Bitmap)imgSrc;
for (int height = 0; height < imgSrc.Height; height++)
for (int width = 0; width < imgSrc.Width; width++)
{
pix = bit.GetPixel(height, width);
red[pix.R]++;
stat.incRed(pix.R);
green[pix.G]++;
stat.incGreen(pix.G);
blue[pix.B]++;
stat.incBlue(pix.B);
}
}
Then the histogram has to be draw into a graphic image. This graphics image is create from the
height and width of the histogram window in the graphical interface.
Before drawing lines, the drawing tool needs to know the size of the pen to use. It could be
calculate by the Width of the graphic where the histogram will be draw divide by the number of
value draw, 256. The pen has the same size for each color to draw, only the color of the pen
changes. Then the line to draw to have the histogram has a height. The maximum possible
height for a value, and draw as the line touch the ceil of the window, will be the number of pixel
of the image,
Page 34](https://image.slidesharecdn.com/0912124-pierrechevillotreport-121212114524-phpapp01/75/Open-Source-adobe-lightroom-like-34-2048.jpg)
![wake up signal is given by the release method, the handler thread acquires the mutex, and could
pick up the histogram image into the histogram thread, and them display it to the user.
Graphical components, as text box, track bar, couldn’t be access from other threads. The only
who could access the component is the thread who has create the component. [STAthread]
attribute of the main function indicate this self‐belong. (STA : Single Threaded Appartement).
The solution to have an access to objects of the graphical interface into a parallel thread is to
have a resort with delegates. Delegate is an object capable of executing a function. It is a
derivate of the Function Object in C++. The delegate function is created with a type “delegate”,
and the header of the function to point on. Then a object of the name of function could be
created. This object could be call by the function Invoke() in a parallel thread. Invoke create a
safe pipe between the two threads.
Page 37](https://image.slidesharecdn.com/0912124-pierrechevillotreport-121212114524-phpapp01/75/Open-Source-adobe-lightroom-like-37-2048.jpg)
![Appendix A – References
[1] Wilhelm Burger & Mark J. Burge, “Digital Image Processing An Algorithmic introduction using
java”, 2007
[2] Tobin Titus, Fabio Claudio Ferracchiati, Tejaswi Redkar, and Srinivasa Sivakumar, “C#
Threading”, 2003
[3] Gerard leblanc, “C# et .Net versions 1 à 4”, 2009
[4] Adobe Systems. « Adobe RGB (1998) Color space specification » (2005)
Page 42](https://image.slidesharecdn.com/0912124-pierrechevillotreport-121212114524-phpapp01/75/Open-Source-adobe-lightroom-like-42-2048.jpg)
Uploaded byPierre Loic Chevillot
Open Source adobe lightroom like
This Honours Project Investigation Report describes the development of a desktop application for image processing inspired by Adobe Lightroom. The application was created using C# and the .NET framework in Visual Studio. It includes features like loading images, adjusting brightness, contrast, saturation and specific color channels. The report discusses image processing concepts, the design of the application interface and algorithms. It evaluates the usability and performance of the completed project.
More Related Content
Open Source adobe lightroom like
- 1. Honours Project Investigation Report Open Source Adobe Lightroom like Pierre – loic Chevillot 2011 A report submitted as part of the requirements for the degree of BSc (Hons) in Computer Science at The Robert Gordon University, Aberdeen, Scotland
- 2. Declaration I confirm that the work contained in this Honours project report has been composed solely by myself and has not been accepted in any previous application for a degree. All sources of information have been specifically acknowledged and all verbatim extracts are distinguished by quotation marks. Signed ……………………………………………………… Date……………………………… The declaration must be signed and dated by the student when each volume of the report is submitted. The work will not be accepted for assessment unless the above declaration has been included and signed. Page 2
- 3.
- 4.
- 5. Table of Contents Acknowledgement ........................................................................................................................... 3 Abstract ............................................................................................................................................ 4 1. Introduction ............................................................................................................................. 7 2. Background .............................................................................................................................. 9 2.1. Image processing .............................................................................................................. 9 2.2. Aims and Objectives of the Project ................................................................................ 10 2.3. Comparison of programming languages. ....................................................................... 10 2.4. C#(C‐Sharp) and its environment: .................................................................................. 12 2.4.1. .Net architecture ........................................................................................................ 12 2.4.2. C# language and version ............................................................................................ 14 2.4.3. Visual studio ............................................................................................................... 15 2.4.4. GDI+ ............................................................................................................................ 16 3. Analyze ................................................................................................................................... 17 3.1. Image Processing ............................................................................................................ 17 3.1.1. Theory: ................................................................................................................... 17 3.1.2. Color space definition: ........................................................................................... 18 4. System Design ........................................................................................................................ 20 4.1. Existing proprietary products ......................................................................................... 20 4.1.1. Adobe Photoshop: .................................................................................................. 20 4.1.2. Gimp: ...................................................................................................................... 20 4.1.3. Adobe Lightroom: .................................................................................................. 20 . 4.1.4. Aperture: ................................................................................................................ 21 4.2. System requirements ..................................................................................................... 21 4.3. Design ............................................................................................................................. 22 4.3.1. Lifetime of the project ........................................................................................... 22 . 4.3.2. UML ........................................................................................................................ 22 5. Implementation ..................................................................................................................... 25 . 5.1. User Interface ................................................................................................................. 25 5.1.1. Loading an image into the application ................................................................... 26 5.1.2. Save of a modify image .......................................................................................... 27 5.2. EXIFF of the picture ........................................................................................................ 27 Page 5
- 6. 5.3. Adjustment Library ......................................................................................................... 30 5.3.1. Brightness and contrast modification .................................................................... 31 5.3.2. Saturation ............................................................................................................... 31 5.3.3. Specific color saturation ......................................................................................... 32 5.4. Histogram ....................................................................................................................... 33 5.5. Threading ....................................................................................................................... 35 6. Evaluation ............................................................................................................................... 38 6.1. System testing ................................................................................................................ 38 6.2. Usability evaluation ........................................................................................................ 39 7. Conclusion .............................................................................................................................. 40 8. Future Development .............................................................................................................. 41 Appendix A – References ............................................................................................................... 42 Appendix B – C# namespaces ........................................................................................................ 43 . Appendix C ‐ Presentation slides .................................................................................................... 44 Appendix D – Project Log ............................................................................................................... 46 Page 6
- 7.
- 8.
- 9. 2. Background 2.1.Image processing Digital technologies have been massively developed during the last few years, and the fall of hardware held digital technologies to be included in lots of large use hardware, like mobile phones, laptops, cameras. One of the technologies, which know a massive deployment on mobile platforms, is digital photography device. Photography device increase the capacity of the sensor to take reasonable good and detailed picture on mobiles phones for example, and the low cost of hardware put constructor to integrate cameras into most of actual market phones. Imaging technology touch now a day a large user population, but this creates a need for low cost or free applications to manipulate images, enhance the image quality, ease to share a image on a social network, or the possibility to integrate images into other digital media. The primary focus of this project is on image processing, and the enhancement on images acquires by classical digital cameras. But image processing could be applied to a wide range of fields: o Robotic: one of the aim of computer science and engineering is build a robot with is capable to navigate in his environment without any human intervention. The robot, and its embedded computer must extract and find out the way to process images (as video camera sequences, sensors, etc) to move in any environment. Image processing is mainly used to extract information like “edge detection”, contrast enhancement, noise removal, to permit the computer vision to have a 3D focus of the scene. One example of this technology up‐to‐date is the “Mars Rover” which is autonomous on Mars, and performs many tasks, without any help of humans. o Medical diagnosis: Biomedical sector now use a lot of imaging devices to detect some disease without being intrusive for the patient, like x‐ray, MRI, CT‐scan. These devices give an image to the doctor that he has to analyze order to give the right treatment to the patient. Image processing gives some tools to have a better definition of images given by the medical devices, and help the doctor in his diagnosis. More the image processing algorithms are powerful to gives a better definition of the images, more the diagnosis could be right. It is now a big research sector for image processing. Page 9
- 10. 2.2.Aims and Objectives of the Project The main aim of this project is to provide a rich‐feature application and open source, which could be executed as a standalone on any user computer to process images captured by digital camera. This project will focus on common used features into processing software. The application implements efficient algorithms for adjusting: Brightness and Contrast, Color balancing, Color saturation The application will provide to user rich information on the image to process, like the intensity of the color contained in the image, and the different information store by digital camera into the image file. Image will be retrieved from disk in formats of industry standard, processed, and results saved in the disk into industry standard formats. The project will be integrate into a usability issue by implementing rich user interface features, and allow the user to see immediate effect of his adjustment operation on the image. 2.3. Comparison of programming languages. The application must be used on local machine, by any user. The better way to create an application is to use an Oriented Object Programming (OOP) language. There are 3 main Oriented Object programming languages well known: C#, C++, Java. Each of the languages has some strength points and weak point. C++: C++ was created in the 80’s to improve the C language (sequential programming language). C++ is an evolved version of C, which introduce the concept of Object programming (concept of programming with class), inheritance, and template. It offers the possibility to work with C libraries, and the C++ normalized library, like “std” which is the standard library normalized in 1998. It is very powerful because you don’t need to go through some interface to put something in memory, or use the processor. This language is very powerful for image processing because it doesn’t requires any fancy layers to gives the data to process to the processor. And some library existing to work on image processing which are powerful. There is a huge library for Graphical User Interface developed originally by Trolltech, and now it is by nosier, named QT. This library offers the possibility to create some rich User interface, with a lot possible options which are free to use by developer. C++ is hard to use due to his old Page 10
- 11. development, even if the language is always upgrade, but the last official ISO normalization was in 2003. C++ used a lot of pointers, which is direct access to an object at the memory address, and the development of image processing could be much harder because it will use a lot of pointers to library functions, objects, and an error is easy made which could corrupt all the application. Java: Java is the most OOP language used for developing application in companies, and educational systems around the world. This language was created in 1995, and created by sun Microsystems (now Java is under Oracle Company who bought sun Microsystems in 2009). Java has removed some of the subtle programming stuff of C++, like multi‐inheritance, pointers and references. Java was created to be all Object Oriented based. Java used a virtual machine to process his data. One of the big advantages of Java is that it is multiplatform. The application could be launch form any Operation System (OS) like Linux, Windows or Mac. It is independent of the computer and the OS, due to the JVM (java virtual machine) which is a layer add on the operating system to run java application. A lot of project use Java for image processing, as the most known is maybe ImageJ. The thing is that Java Virtual Machine consumes lots of resources on the computer, and the application will consume more. The application must done the job require the quickest as possible, the virtual machine is a brake to that. C#: C# is the language created by Microsoft in 2001. This language was created to be integrated in the .Net (dot net) platform, as the same point it provide a totally independent Oriented Object Programming language. This language is a mix between Java and C, C++. It provides the easy writing of Java, and re‐implements some useful thing of C++. This language is based on the Framework .Net (which gives the possibility to create application with many Microsoft languages, Visual, visual C++, and merge them into a biggest one without any deployment problem). The Framework works with CLR (common language runtime), which is relatively the same as the JVM of java, but which is integrated in the last version of Microsoft Windows. C# has some portability on other platform than Microsoft, it is call “project Mono”, which try to provide the .Net framework for Linux/Unix platforms, under a GNU license. The thing is to choose a powerful language, and easy writing language to create the project. Due to the comparison, C++ and C# seems the more powerful, and quickest language to work, because it didn’t require any further Virtual Machine launch and taken resources of the computer. Then the easy writing is more provide by Java, but C# is a good compromise either Page 11
- 12. due the IDE (integrated development environment) named Microsoft Visual Studio. C# seems the better language as a compromise to work directly on the resources of the computer, and the easy developing writing tool. 2.4.C#(C‐Sharp) and its environment: C# was created in 2001 by Microsoft to integrate a powerful Oriented Object Programming language in their .Net platform. C#, for Microsoft, has to be a simple and modern oriented object programming language. 2.4.1. .Net architecture .Net (dot net) was based on a architecture on Windows layer. This layer consists of a collection a DLL (Dynamic Link Library), which could be incorporates into a project, or directly incorporate in the last windows kernel, and just need to call them. This Microsoft windows layer is composed of thousands of class, because as explained in the previous section, C# is all object oriented. The class (included in dll’s), could be used by any Microsoft languages as the same way to create an application. The classes provided are used under the .Net executing environment called the runtime. The Run‐time .Net is in fact as the virtual machine for Java, but it is integrated into the Microsoft environment. The run‐time .Net provides services like: Load and managed execution of applications. Isolations of the application one to each others. Translation of byte code to Unicode when the application is running, called Just In Time Compiler. Check of the accesses in the memory. No possible access out of the allocate area of the application, and same for the array allocated in the application. Memory management with a garbage collector. Automated adaptation of the National characteristics (languages, numeric and symbol representation, keyboard transcription, etc) Gives a compatibility with COM modules, but not managed by .Net framework. The COM modules are simple computer based around a micro‐controller and some RAM, with a small physical size and low power consummation, created to work on embedded system. Page 12
- 13. On the .Net architecture, classes are sort into “namespaces”. A namespace regroup classes which have the same utility, or work into the same domain of knowledge, like security, Input/output, etc. (Appendix B) Like mention previously, .Net framework provides a full compatibility of all the languages of the .Net framework. Any class could be use as the same way in all managed code for .Net (except of the syntax of the language). .Net provides a type of polymorphism through language compatible .Net, like you could create a class in one language (C#), inherit this class in another language (VC++), and finally implemented this class in a third language (VB, visual basic). For the language of the .Net Framework, they need to have the same characteristic to be compatible. The languages need to have the same representation of the data type (size and representation in memory) named CTS (Common Type System) which regroup all the characteristics. CTS is the normalization through all the .Net language to specify how Type definitions are represented in computer memory. This CTS helps to enable cross‐language integration, type safety and high performance code execution. The compiler of .Net generated an intermediate code which in situate in the middle of the machine code (basic level) and software code (high level). This code is independent of the low level code, and is capable to manage high level object construction. At the moment of the running of the application, this code is not interpreted, but compiled by the JIT compiler. At the first call of the execution, and only the first one, the “Just In Time Compiler” will know the execution environment. This knowledge of the execution environment will provide to JITC to compile the code as the better native code for the model of processor of the actual user, like that it will result in optimization of the native code for the microprocessor. Microsoft .Net languages are: Visual C++ Visual Basic, which was refractor to be full object oriented. C# that became the reference language of Microsoft. Many others languages could be integrated in the .Net architecture. As Python and Ruby who could be use officially to develop some Silverlight application. Silverlight authorize to create some web application which are executing on the client computer. But Microsoft doesn’t limit the usage of its .Net Architecture at only these languages. Microsoft provides a full documentation for compiler supplier who wants to create a .Net compatible Page 13
- 14. version of their product. The adaption will be make on the generated code buy the compiler, which authorize to uses the same classes and development tool, and language could be integrated into Visual Studio (Chapter 2.4.3) Languages who want to be integrated into the .Net architecture has to follow some edited rules. The rules make the CLS (Common Language Specification). But for each piece of code which could be reused by any part of the whole application, the compiler need to generate a “self describing component” for this piece of code. The information contains into the self describing component, are the classes, properties, public methods, and libraries used into the assembly (executables, exe, or library, dll, files). 2.4.2. C# language and version C# is now the main language of Microsoft. It was diverted from C++, but taking also lots of characteristics of recent languages, as Java. But C# evolved and now introduces some new concepts. C# implements some good new functionally since C++, as: Better Object Oriented Programming integration, everything must be incorporated into Classes. Types have to be conforming to the .Net Architecture, and safe Type casting. Pointers could be use by developer, but should be use for optimization. Automated liberation of non‐use Object with the Garbage‐Collector. Translation of array pointers by references on array. This offers the same possibilities, but more safe, and without any loss of performance. Better management of array manipulation, with more security. Integration of the “foreach” to make some loop. C# could be also use to create web application with ASP.NET or Silverlight. This is two different model of creating web application. ASP.NET creates application on the server side. It authorize ton insert some C# (or VB.Net) source code into HTML web pages. The website could be use by any client without asking anything more; the web browser will interpret the page as a classical website. C# is only use to modify the information that the web browser will display to the client. Page 14
- 15. Silverlight is a client side web application. Silverlight will deploy the application on the client computer. C# will be used to interact with the client. The application communicates with the server, but without using the resource of it, just requires the information the client needs when using the application. Silverlight uses XAML and WPF as well to provide events, buttons, etc.. C# is a very young language, but it already has a lot of different versions. Each version adds a valuable evolution to the language, and to the .Net Architecture. The version 1 and 2 are mostly the integration of new functionally and the development of C# to the .Net Architecture. Then since the version 3, in 2007, Silverlight and Rich Internet application comes into the language. And now on the version 4, since 2010, the most important innovation is the parallel treatment on multi‐core computer. 2.4.3. Visual studio Visual Studio is an IDE (Integrated Development environment) created by Microsoft for its .Net Framework. Visual Studio gives to developer the possibility to create console application, as rich graphical user interface application, as Web sites, services or applications. This IDE gives the developer the choices of the language he wanted to use from the .Net compatible language. As a classical IDE, visual has a debugger included. This debugger is not focus on one language, but was develop to debug some cross language application which could be develop on the .Net architecture. But for the Project, I will only need to use the debugger on C# environment. One of the good tools of Visual Studio is “IntelliSense”. This tool is the Microsoft auto‐ completion tool, and integrates a short description of Types in a pop‐up window. During the writing, IntelliSense could suggest some statement to help the developer. There is another tool to have a better organization of the source code, it is some define region. You could name some regions of your code inside #region name … #endregion. Like that it regroups you function inside a sub list you could display or hide if you need it. Page 15
- 16.
- 17. 3. Analyze 3.1.Image Processing 3.1.1. Theory: Image processing is the technology that uses algorithms on images, for different purposes. This technology uses the base of the Imaging Technology, to translate the optic view of an image into Digital image. This digital image could be treat by some image processing algorithm afterwards. For a human, an image view by the eyes is a multitude of light point. In the retina, Rods and Cones are two major light sensitive photoreceptor cells. These two cells give to human a certain light and colors sensibility. Rods are more use by the body for the low light sensibility, it is responsible of the monochrome vision we could sense when we are in a room with no light, but we can navigate through because we felt the obstacle. Cones are colors sensitive. Each cone is sensitive of a range of the wavelength of the spectral representation of the light. (Figure 1) Figure 1 In white curves, it is the sensibility of the cones, and the black one is the sensibility of the rods. The computer representation is made by Pixel. A Pixel is a representation of point of light. It is encoded on 32bit, but only 24bits are use for the color representation, 8Bits for each Red colors, Green and Blue. The last 8bits could be either not use, or use to represent to transparency of the image, this is call the alpha channel. Page 17
- 18. 3.1.2. Color space definition: RGB: The color space RGB (Red, Green, and Blue) could be easy understood because all possible colors could be made from the three primary colors. This color space model is become the main model for computer graphics. Two color spaces inherit from the basic model of RGB are now mostly use in monitors (LCD, phone, etc) Adobe RGB: design in 1998. This color space is designed to restore the color which to be achieved on printers, on computer display. sRGB: developed in 1996 by the collaboration of Microsoft and HP to be use on monitors, printers and Internet. This design is now the default color space for many devices such as printers, monitors, phone, video camera, etc. The colors we perceive are not a mix of the three components, but more like a combination of light intensity, and coloration. The coloration gives the shade, and the saturation. The shade is the color perceives, like blue, cyan, yellow, and the saturation is the purity of this shade, which could be gray for a very saturation, and maximum for pure color. That is the reason of if we increase the brightness of a scene, it produce a proportional increase of the reflected light by the object of the scene for the wavelength. So for this example the component RGB will be multiply by this constant, but the saturation and shade will not change. The Luminance is the intensity of light received. This is normalizing by the ICE (International Commission of Illumination) as the codification of Red, Green and Blue lights as a combination of each of them: Y = 0.2125 R + 0.7154 G + 0.0721 B The addition of the 3 coefficients is equal to 1, but there is a different between each coefficient. This explains the different between the perceptions of for each luminance. A green light will seem brighter than a red one, and more than a blue one. But in the encoding of a color, it needs to add a complementary data to the luminance. This complementary data is the Chrominance. The Chrominance is linear combinations of 2 numbers Page 18
- 19. to represent the intensity of Red, Green and Blue. The ICE has codified information into a chromaticity diagram who takes the form of a half eclipse.(Figure 2) Figure 2 The RGB color space representation could be modifying to be as HSV (hue, Saturation, Value, or B as Brightness) representation. HSV representation is a cylindrical representation of RGB color space. It was developed in 1970, to be used as a color modification tool for image editing software, and image analysis of computer vision. The translation of RGB to HSV could be done by the transformation Page 19
- 20. 4. System Design 4.1.Existing proprietary products Now days, a lot of different applications were created to give some tools to edit image for any user of a digital device. This application provides lots of different tools, and some applications are focus to be use by professional of photography, or by graphic editors. 4.1.1. Adobe Photoshop: Photoshop is a huge application for image processing, and maybe one of the most knew. This software has a lot of image algorithm library included. It is focus to be use by professional, but most of users are none professional. Photoshop has basic image processing tools as easy cropping tool, colors modification, and filters to apply. It is really easy to use these basics tools due to a good graphical interface given by Adobe. But more of the power of Photoshop could be find in the menu tool bar. This regroups a lot of vary algorithms to be use to create, modify or add effects on images. Creation of images could be done from scratch. Photoshop works with masking tool. The mask is a layer where graphics objects are drawn, and overlay one to each other. Effects could be done on one mask, or a set of masks. And different light effects could be done on the overlay masks. Adobe Photoshop is one of the most powerful application, but it is most to use for professional people which work on graphic of photography montage. 4.1.2. Gimp: Gimp is the open source version of Photoshop. The developing team tries to provide the same functionally as the Adobe one. Gimp is a good solution to make graphic and image processing on Operating System as Linux, where Adobe products couldn’t be use. Gimp provides a wide range of good tools for image processing, as Adobe Photoshop. But it is very difficult to use. But the software is free to use, and always update by the developing team. 4.1.3. Adobe Lightroom: Adobe Lightroom is an image processing software creates for professional photographers. This software is creating to simplify the post‐processing of their work. Lightroom is creating to manage a library of images, adjust images and exporting on printer or publish on a website gallery. The import tool of the software gives the possibility to select images to import before importing them on the computer. Page 20
- 21. The principal usage of Lightroom is the development section. The section is split into a histogram, and some functions to act directly on the image. All the modifications are none destructive on this software. The modifications are store in a separate file from the original picture file. The user needs to print, or export his picture to apply the modification. At this moment a new file is create in classical compressing format (JPG), or a new digital format create by Adobe, Digital Negative format (DNG). On basics adjustment for picture, we can find algorithm to adjust the temperature of an image, brightness and contrast, exposure level, saturation level, and conversion into Black & White picture. But Adobe creates some new algorithm like clarity and vibrancy. Clarity change the contrast in the middle range of the histogram values, and Vibrancy increase the intensity of less representative color in the picture, but without burn the other colors. The new thing is that Lightroom could correct lenses deformation. The software extract the Exiff information to know the lens used, and apply the right correction to the picture. This application is create for a professional use of photography, and to give more time for the photographer to practice photography than post‐processing of his image. It is a solution for professional who don’t need all the functionally of Photoshop, and a quick answer to their main problem of post processing. 4.1.4. Aperture: Aperture is the same software as Lightroom, but created by Apple. This software works only on Mac operating system. 4.2.System requirements The project is design to be like commercial software of image processing. This project provides some quick access tools to adjust an image. The system need to load an image of a standard compression algorithm, jpeg (joint photographic experts group, jpeg is a algorithm to encode and decode photographic image use by all digital devices who captures pictures). The system has to save the modify picture on the same schema. Projects will display the information store into the image (EXIFF), and calculate an histogram of it. Page 21
- 22. Some modification tools will be providing as: Brightness modification Contrast adjustment Saturation level adjustment Color filter adjustment 4.3.Design 4.3.1. Lifetime of the project The project is made on the plan of prototyping and evaluation. This plan intends to create a first quick prototype with some basic functionality, then evaluate this prototype and debug it. When the evaluation is reasonably good and efficient, a new prototype is created with more functionality, and the process of evaluation restart. This process of prototype, evaluation could be done until a prototype is enough evolve to be release as final project. In the time life of this project during honors year, some prototypes were create and evaluated before going on more feature. The project on the day of the presentation will be a part of the evaluation phase, on the threading implementation. 4.3.2. UML The creation of diagrams is made in Visual Studio 2010. This could be made by adding a modeling project, and in this project, Visual Studio could create projects as UML diagram. Diagrams are store as a part of the project, and could help anyone who comes on the project without have external source to understand the basic architecture of the project. 4.3.2.1. Use case diagram: The user will require this application to make some simple actions. All the action a user could do on the application could be draw in a use case diagram. The use case will represent all the action that could be done by a user, without taking part of the software engineering, and the technologies use in the project. Page 22
- 23. Figure 3 User can do 2 main tasks, has Information, or made adjustment. In the information section, the user could have information about the EXIFF of the picture, or read a histogram. In the section part, the user could do 3 actions, adjust the brightness, the contrast or the saturation. For the saturation, the global and the specifics color are 2 options inherit from the main action. 4.3.2.2. Class diagram: The project will be split into the application and the adjustment library. This library will be store in an additional library, compile as a DLL (dynamic link library). This Page 23
- 24.
- 25. 5. Implementation 5.1.User Interface The project is design to be use by everyone. The user could be a professional of photography, or a standard user who want to adjust one of his pictures. The main requirement for a good graphical interface is a clear view of the possibility provide by the application. On the first launch of the application, the user has to quickly understand where he needs to act on the interface to make what he wants. The interface is design to be easy understandable at the first view of any user. For that, some paper drafts were drawn. An evaluation of drafts was done, and one interface was selected to be tried on the Graphical User Interface designer of Visual Studio 2010. (Figure 5) Figure 5 The design is compose in the main area of a Picture Box component. The Picture Box element is a graphical element in C# designer, to load a picture into it, and display to the user. It could load different types of images, as .bmp (bitmap), .jpg and .png. On the left of the interface, a tab panel is implemented. This panel could display information about the pictures, and modification tools, depend of the selected tab. There are actually 4 tabs. The first one is use to display information about the image (Exiff) and the histogram of the Page 25
- 26. representation of the intensity of color component in the image. Second tab provides some tool to adjust the brightness, contrast and saturation of the image. The level of adjustment could be select by the track bar. This could be more right to left, to increase or decrease the intensity of the effect. The Track Bar element authorizes a range of values between ‐100 to 100 and is at 0 to default. The third panel is a Hue/Saturation adjustment panel. In this panel you could adjustment the level of intensity for particular color. The modification of this level is control by a Track Bar with the same range of value for the adjustment panel. The last panel is in preparation of the next evolution prototype. It has nothing in it for the moment. On the Left side of the interface, there is a column. This column is empty, but it is the same as for the “Noise Reduction” tab, it will be use in a future prototype. In the original design, this column will display some vignette of pictures loaded. The user could navigate in the picture he wanted to modify by clicking on the vignette of the picture to see it in the main zone, and then apply the modification to it. In the menu bar, the “File” Menu Strip gives 2 others Menu Strip to load and save an image. 5.1.1. Loading an image into the application When the user decide to load an image, he uses the File / Load.. Menu. This will open a Load dialog box. This dialog box is a class from the C# library. In this box, the user can navigate into the directory tree of his computer to search his image. On this load dialog box, the application applies a filter to restrict the display for only JPG image. if (open.ShowDialog() == DialogResult.OK) { Bitmap temp = new Bitmap(open.FileName); img.loadImage(open.FileName); MainBox.Image = img.getImage(); //TODO modify GUI to be automatic stretch & resize MainBox.SizeMode = PictureBoxSizeMode.Zoom; } The openFileDialog object is initiate this a filter to sort only .jpg images. This piece of code, open the image selected in the dialog box, set it into a Picture image, and load the image into the main picture display component (MainBox). The image is after stretch to fit in the picture box zone. Page 26
- 27. The picture object contains a bitmap, and the difference information that the image could have, as EXIFF. 5.1.2. Save of a modify image The application saves the image in JPG format. The simplest way to save the last modify image is to take it from the main picture displayed and give it to SaveFileDialog tool to save it as a JPG image. 5.2.EXIFF of the picture Exiff of a picture are information store into the picture. Information could be much diversified, like the information of how the picture was taken, or the different parameters of the camera who take the picture, etc. All the information are store as metadata. The metadata is a simple information store at a specific place in the file. Each metadata is encoded at exactly the same place in JPG file. Each byte representing the metadata in the memory of the JPG file will be a property of the Image class in C#. To sort out the properties we are interested in, we need to how exactly what address corresponding to which property, and how it is encode. The project focus on only some specific properties regroups in the spreadsheet bellow. These elements are the main elements a photographer, or people interested in photography want to look at. Property name Address in JPG file Encoding Focal Length 37386 Int16 ISO Speed 34855 Int16 Aperture 33437 Int16 Exposure Time 33434 Int16 Creation Date 306 Ascii Make of the Camera 271 Ascii Model of the Camera 272 Ascii Metering mode 37383 Int16 Orientation 274 Int16 A picture taking by any camera is a combination of 4 parameters (Focal length, Aperture, Exposure Time, ISO speed). These parameters regroup optical techniques, and electronicals Page 27
- 28. device for digital camera. Most of the camera not gives the possibility to play with these parameters independently, but Digital SLR camera did. That’s why for a photographer the information are important. Focal Length: The focal length is much knows as zoom. In fact it represented the measure of the convergence of the light into a lens. ISO Speed: The iso speed will define the sensibility of the captor. If the value is high the sensibility of the captor to the light is very accurate, but the sensor will also made noise on the image because the sensor start to heat due to the amount of light coming on. The default ISO speed for a picture without noise is 100, after it depends of the camera. Aperture: The aperture is a number to represent the maximum opening of a lens. The opening is big when the number is low, and the hole reduce when this number increase. For example a Aperture of f1.8 will provide a very light lens, and f4 is darker because the stop where the light go through is smaller. The aperture will provide the focal distance in a picture, the lower the aperture is, and the lower the focal will be. This could be seen with a blur background very present at high aperture (low number), and a detail background for low aperture. Figure 6. f/1.8 (left) and f/5.6 (right) On the first picture, the aperture is open at the maximum of the lens (f/1.8) on a 50mm, and the second was taken at f/5.6, which is 10 times close. The deep of field in the first picture which a very large aperture is reduce, and only the flower in the middle is net, even the leafs are blur. In the second example the deep of field is greater. The flower and leafs next are in the net section of the focus, and the background has more information that the first one, but is still blur. Exposure Time: this is the time the sensor will be exposing to the light, and get the information to create the image. On analogical camera, it was the time during the film was expose, and the light print on the image. Now the sensor is digital, and convert light into data to create the image. This time could vary a lot, it depends of the picture you want to do. You can fix the image Page 28
- 29. with a very quick exposure time, or make the image dynamics with a control movement of the camera which could be retranslate in the image. The left image has a quick exposure time, and instant the image. The wave is taken in its move and instant. The second image on the right, the exposure time is extend. The sea make like a fog on the rocks. Exposure Time, Aperture, and ISO speed are the keys to the intensity of color in a picture, and the quality of the picture. Page 29
- 30. 5.3.Adjustment Library The project is base to make some adjustment on image. All the functions to make the adjustment are store in a package out of the Graphical User Interface, in a dynamic link library (DLL). This DLL has only one class, with many functions which can be use by any project who want to include the DLL in its linked library. The main usability of the DLL is to be reusable in any project, without the need of rewrite everything. This DLL gives the adjustment function for: Adjust Brightness and Contrast Saturation level Saturation of specific color. The algorithm is base on an color matrix modification to apply on the whole image. C# has a class name “ColorMatrix”. This matrix is the representation of a pixel encoding. It is compose of a 5 x 5 matrix, the first three line represents the three main component of the color space (Red, Green, Blue), then there is the line for the Alpha channel. The last line is use to add a value to the color channel component corresponding to the column. R 0 0 0 0 0 G 0 0 0 0 0 B 0 0 0 0 0 1 0 A A A 0 1 The 4th line, representing the alpha channel, is never use. Alpha channel represent the transparency on the image, and the project requirement as no function with any transparency modification, so the value of the alpha channel never change. The matrix is use to avoid the other algorithm which consist of opening each pixel, and them modify the value of the component it has to be change, then close the pixel, and go on the next one. This techniques on iteration on each pixel manually is time consuming, and especially on image taken with DSLR camera which could be easily around 18Mpx, so 3456 * 5184 = 17.915.904 pixels to open. ColorMatrix class in C# uses the class ImageAttributes to apply directly the new matrix of color on it. Then draw a new image, which is display to the user to have the result of the actual modification. Page 30
- 31. 5.3.1. Brightness and contrast modification The contrast modification will be the coefficient by how the component will be multiply, and the brightness will be the sum to add to the component. float v = 0; v = (float)(cValue + 100) / 100f; float m = 0.5f * (1.0f ‐ v) + (float)bValue / 100f; /// The matrix is compose of 4 lines for Red, Green, Blue parameters /// then the line for Alpha parameter /// and the identity line which is use to multiply the matrix cm = new ColorMatrix(new float[][]{ new float[]{v,0,0,0,0}, new float[]{0,v,0,0,0}, new float[]{0,0,v,0,0}, new float[]{0,0,0,1,0}, new float[]{m,m,m,0,1} }); ImageAttributes ia = new ImageAttributes(); ia.SetColorMatrix(cm); The cValue in the previous example code represent the contrast value given on the track bar, and the bValue the brightness value on the brightness track bar. The contrast value is translated in a first time as a value to multiply on the color component. If the contrast value is 75, colors component is multiply by 1.75. Then the brightness will be add. The brightness value is compute as a number between ‐1.0 to 1.0. If the contrast is change in the same time, the value of the contrast is taken in the algorithm. This change the brightness by the half of the difference between the vector of the contrast to the normal contrast vector. (0.5f * (1.0f ‐ v)) 5.3.2. Saturation The color saturation is used to describe the intensity of color in an image. Most of saturated images have overly bright color. De‐saturation of a color translates the color image into a monochrome one. The saturation algorithm use 3 weighs value given by adobe as the luminance value for the color. The color green is highly recognizable by human eyes, so it luminance value is high, blue is the color that human eyes has the less perception, and red is in the middle range. The sum of the three values makes 1. The weight must be add the value of the saturation given Page 31
- 32. by the track bar. Color saturation is weight and the complementary color has to be weight to. The all matrix will be multiply. The main component of the color is weigh by the luminance, and then the saturation vector is apply in addition. Complementary colors are only weight by luminance vector. float red = (float) 0.3086; float green = (float) 0.6094; float blue = (float) 0.0820; float sat = (float) (satValue + 100) / 100f ; float redSaturation = (1 ‐ sat) * red + sat; float redSaturationComp = (1 ‐ sat) * red; float greenSaturation = (1 ‐ sat) * green + sat; float greenSaturationComp = (1 ‐ sat) * green; float blueSaturation = (1 ‐ sat) * blue + sat; float blueSaturationComp = (1 ‐ sat) * blue; cm = new ColorMatrix(new float[][]{ new float[]{redSaturation,redSaturationComp,redSaturationComp,0,0}, new float[]{greenSaturationComp,greenSaturation,greenSaturationComp,0,0}, new float[]{blueSaturationComp,blueSaturationComp,blueSaturation,0,0}, new float[]{0,0,0,1,0}, new float[]{0,0,0,0,1} }); 5.3.3. Specific color saturation The color filter not given the results wanted. The algorithm gives the possibility to apply a color filter on the image. Normally to saturate a specific color, the channel of this color has to be multiply by a vector, and the others channel not changes. And the de‐saturation has to apply a filter where the others colors can go through, but not the color we want to de‐saturate. The human vision is a perception of color, if a filter is place before eyes analyze the color percepted, one color could be remove (filter). Page 32
- 33. Figure 7 There are 3 filters to block primary colors: Cyan : block Red, let Blue and Green Yellow : block Blue, let Red and Green Magenta : block Green, let Red and Blue float blue = (float)0.0820; float sat = (float)(satValue + 100) / 100f; float blueSat = (1 ‐ sat) * blue + sat; float bComp = (1 ‐ sat) * blue; cm = new ColorMatrix(new float[][]{ new float[]{1,0,0,0,0}, new float[]{0,1,0,0,0}, new float[]{0,0,1,0,0}, new float[]{0,0,0,1,0}, new float[]{0,0,blueSat,0,1} }); ImageAttributes ia = new ImageAttributes(); ia.SetColorMatrix(cm); 5.4.Histogram One of the ways to evaluate if an image is good, is to check the histogram of the image. The histogram will be the statistics of the intensity of the color present in the image by a graphical way. Histogram could also be to show the brightness of a image for monochrome picture. Drawing a histogram require to calculate some statistics as pre‐processing. A pixel stores a color component as a value of 8bit, so the value for a color varies from 0 to 255. (28 = 256) A value of 0 in the color represents a total absence of this color, and 255, that the color reaches it maximum intensity. The black color is the absence of any of the 3 primary component, so it will be encode Red = 0, Green = 0, Blue = 0. And the inverse for the white, but for the color blue the Page 33
- 34.
- 35. 5.5.Threading Image processing requires a lot of computer resources, and calculation time on the processor. Thread is a processus which is launch in parallel to execute tasks. In fact program of application is threaded on actual operating system, there is only one main thread (init), and the operating system and software are just other thread. Thread make tasks in parallel without blocking other thread execution, so the two processus seems to be executed simultaneously. The main resources consumer is the calculation of the statistics, and the drawing of the histogram, for the project. To avoid any blockage on the Graphical User Interface, due to the time the computer takes to compute statistics of the image, the best method is to execute that in parallel of the application. One thread takes the calculation in parallel of the main executing thread where the GUI is. The thread calculate and draw the histogram, before indicated to the main thread, he has finish his job, and the main thread could get back the image of the drawing histogram, and display it to the user. In the project, the object PictureBox has a method “refresh”, but this method is call to often, and it is link to the main thread, without any method to delink it to include the synchronize method in it. The solution is to create a second thread, with the role of being the handler of the display of the histogram when it is ready. The project has in fact 3 thread, which must be synchronize each other to work in parallel without make any deadlock, and block the application. Different techniques were tried during the time of the project, but the technique finally use is with a semaphore. The other techniques could solve the same problem but often with more complexity. This synchronism problem could be solving either by: Background worker: The background worker is a class which does a work in background, and could give the progress of its done job. It is use for simple problem solving, which require quickly a big computational resource. Interlocked : the class interlocked gives some tools to work on arithmetic operations without been interrupted ReaderWriterLock: This class implements the solution of the problem of reader and writer. This problem is one of the class study example to explain thread and deadlock. Mutex: Mutex is a class to implement mutual exclusion. It is mainly use to synchronize threads which maybe not inherit from the same processus. A mutex could be seen as a flag, and only one thread at a time could posse this flag. Every thread who want the flag Page 35
- 36. will be put into wait state, and when the flag become free, only one thread could acquire it. The project implements another type of synchronism with a semaphore. The semaphore is a simple object with only a value in it initially put a 0. This class is share between thread, and thread could try to acquire the value, or release a value in the semaphore. These two methods are protected with into a critical section with the class monitor. When a thread want to acquire the semaphore, the semaphore will give him the value (in fact reduce by one the value in the Semaphore), but if the value include in the semaphore is 0, the semaphore put the asking thread into waiting state until a thread release a value. The Release method enter in the critical section to add a value, and then signal to waiting thread on the semaphore that a new value just has been posted, and them to wake up. class Semaphore { private int val; public Semaphore() { val = 0; } public void acquire() { Monitor.Enter(this); while (val == 0) { Monitor.Wait(this); } val‐‐; Monitor.Exit(this); } public void release() { Monitor.Enter(this); val++; Monitor.Pulse(this); Monitor.Exit(this); } } The synchronism has to be between the painting handler thread, and the histogram creator thread. Like the creation of the histogram must be signal, the histogram creation thread call the release method after the end of the drawing histogram function, when the histogram image is ready to be picking up by the handler. The handler thread during this time is trying to acquire the semaphore, but until the histogram is not ready, this handler is put in wait state. When the Page 36
- 37.
- 38. 6. Evaluation 6.1.System testing Application is develop on the base of an evolving prototype. The system is test all along the develop life time. This technique allow to discover some bugs, or errors of design made, and quickly change them, without crash the all application, or change the development plan. The first set of tests was made on the design of the graphical interface. Test tried to evaluate the interface, and see if any elements could be better organize. Tests were made with different unitary console write to test the action performed on the interface. The second set of tests was made after the implementation of the EXIFF print tool. EXIFF are place in the same place for each jpg image, so for any photography take with a DSLR, a compact or a phone device, the image should includes EXIFF. Tests work well especially on DSLR and compact photography device. The aperture made only wrong value for under F/2, for example an aperture of f/1.8 is transcribe as f/.9.The other things coming back during the test is that not all the device register EXIFF, for example some pictures from camera on phone doesn’t have any EXIFF, and a null value is now set is no EXIFF is found. Third set of test is on the Adjustment library. The library must product the adjusted image quickly as possible, but also has a good render on the display image. The brightness and contrast algorithm give back an image as the potential of some commercial software like “Adobe Lightroom”, as the same for the saturation algorithm, which on human perception is exactly the same render. Last set of tests, is on the implementation of the histogram tool, and the threading of the application. The histogram was working without threading, but stops the application during a time of around 10sec, and when it needs to be recomputed it was the same. That’s the main reason of the threading of the application. The histogram calculation has not to disturbed the normal utilization of the whole software. Threading the application is made with lots of different try to find the best way to thread, with a lot of time spent of interblocking thread without blocking the GUI. This includes the usage of Mutex, background worker utilization possibility. Threads interblock each other without causing any deadlock, but the delegate parts not working. The delegate implement is really new in the development life time, this is find when threads were working properly, but no histogram is display to the user. Page 38
- 39. Algorithm is try against the commercial software Adobe Lightroom. Brightness and contrast algorithms are little less powerful than the commercial product, but have significant results to be classify as good for the purpose of the application. The saturation algorithm gives the same results as LightRoom. This algorithm is slower to be applying on image, but as the results is the same as the commercial product. The time is not the main purpose for a general user, but it will count for professional use. 6.2. Usability evaluation Evaluation usability was made on people more or less related to photography. The evaluation for non photographer is base on usage of the interface, and the speed of the application. Users find the interface not hard to use. This is mainly due to the tabs classification of the different options (Information display and Adjustments). The speed of the application is enough good for them. There is some points in the interface to be modify to have a better general usability; like the possibility of enter directly the number of the adjustment, and a cropping tool. For photographers, the application is too slow to apply the modification, but the interface is nice to use. Tabs coming back as a good tool to classify the different options provided. A cropping and rotation tool could be a really improvement to the application. But most of the feedbacks are a good start for an image processing tool for armature. Page 39
- 40.
- 41.
- 42.
- 43. Appendix B – C# namespaces Namespace Description Classes Example System Basic type access Int32, Int64, Int16 Console access Byte, Char String Float, Double Console Type System.Collections Object collections ArrayList, HashTable, Queue, Stack, SortedList System.IO Files access File, Directory Stream, FileStream BinaryReader, BinaryWriter TextReader, TextWriter System.data.Common Databases ADO.Net access DbConnection, DbCommand, DataSet System.Net Network access Sockets TcpClient, TcpListener UdpClient System.Reflection Metadata access FieldInfo, MemberInfo, ParameterInfo System.security Security control Permissions, Policy Cryptography System.WinForms Windows oriented component Form, Button, ListBox MainMenu, StatusBar, DataGrid PictureBox, TrackBar System.Web.UI.WebControls Windows oriented Buton, ListBox, HyperLink, components for web DataGrid Page 43
- 44. Appendix C ‐ Presentation slides Page 44
- 45.
- 46.