gen_5.1.gif
Screenshots
Help
Download
Developer motto
Donate
About

 

Raw Image Analyser Help

Raw Image Analyser Help file

Manual index:


Basic usage

The application's main goal is to allow dynamic and informative Side-By-Side image comparison with emphasize on RAW images and flexible means to adopt varying loading of input files. The S-B-S image comparison is the core feature which allows a user to analyze image pixels of N correlated images in the most effective way. This is achieved by selecting several images (refer to Hot-Keys and Mouse control section) and then every action taken on one of them is affecting the entire group (comparison party). Note that the application takes the approach of minimal layout overhead i.e. there's no usage of tool-bars, over rich menus or pop-up windows. This is done to enable the maximal focus on image's data / pixels. All actions can be quickly accessed via a compact set of hot-keys and minimal mouse actions. It's also possible to work with the application via command line and configuration file. At the bottom you'll find an informative Status-bar that holds file info, image info and app modes info. One of the problems with RAW images, such that simply pack a group of pixels, is that they carry no meta info such that a SW might parse and be able to open them with a single click. As such, the app offers a "pseudo-training" feature that uses a powerful tool called reg-ex (short for regular expression). If you're a developer, then this is a must know for but if you're not, know that 99% of all daily-used patterns can be matched with such a reg-ex string pattern matching. All is required from you is to direct the app (see Formats file section) how to parse a file name with a variety of group options. Although the app flag-feature is RAW images (mainly luma, RGB and YUV family), you can still use it to open most common file types like JPG, PNG and others. The app is used mainly for viewing and thus, it refrains from "touching" the input images unless the user specifically directs a file save over them. Manual terminology:

  FIFocus-image
  ZFZoom factor
  HKHot-key shortcut
  ROIRegion of interest (rectangular area of image)
  LE/BELittle endian (default on x86), Big endian
  <Char>Case-sensitive hot-key (HK)
  [Char]Case-insensitive HK
[Back to main index]

Hot Keys

Summary:
KeyShort description
Hot Keys: Navigation
1..0, Shift + 1..0 Quick-change current open image view
[*] Set the ZF to Fit-To-Window
[+] Increase the ZF one step up (zoom-in)
[-] Decrease the ZF one step down (zoom-out)
Navigation keys left, right, up, down Scroll image view by page intervals
Tab / Shift+Tab Switches between open images forward/backwards
~ Back key, for quick-toggling 2 recent images
<x> Close an image
<X> Close all open images (or comparison party images)
F1 Show the overlay help screen
ESC Generally, aborts any user-action phase
Hot Keys: View / Basic analysis
<c> Start Compare mode image collect phase
<C> Try to auto collect all images that are of FI type
<cc> Alias of <C>
[L] Layer mode on/off (on active comparison party)
[G] Grid mode on/off (ZF 5+)
[V] Pixel View mode on/off (ZF 5+)
[H] Toggle pixels values between Hexadecimal and Decimal
[T] Coordinate Tracking mode on/off
[O] Coordinate Offset display mode (under Tab) on/off
[J] Start a "Jump to coordinate" session
Hot Keys: Advanced analysis
<r> Ruler mode on/off
<R> Open the Ruler Config dialog (modeless)
Ctrl-[R] Toggle between a set of ruler colors
[M] Toggle ruler style between Matrix / Indent lines
[I] Open the information overlay (statistics + histogram)
<b> Toggle overlay info (histogram) transparent view on/off
<B> Toggle overlay info transparent shadow affect on/off
Ctrl-[B] Rotate the overlay info transparent view FG colors
[A] Beautify decimal values for overlay data on/off
Hot Keys: Analysis assist actions
[D] Difference between 2 images (in Compare mode)
Ctrl-[D] Toggle between the 4 diff modes
<f> Filter Colors dialog (mask out pixels)
Ctrl-[F] Apply the last used Filter
<F> Remove the current active filter
[E] Image Evaluator (I-Eval) dialog
Ctrl-[E] Re-apply the last edited I-Eval
Hot Keys: Generic image operations
<s> Enter Save Image Mode (full image or ROI)
<S> Save/export image to PNG (RGB-8) (full image or ROI)
Ctrl-[S] Toggle the auto-naming mode on/off
<n> New by duplicates of current image (or ROI)
<N> Convert RAW (to a new) image dialog
Ctrl-[C] Copy to clipboard image (as BMP RGB24) or path/title
[P] Copy to the clipboard the current pixel coordinate and value

Hot Keys: Navigation

1..0, Shift + 1..0 Quick-change current open image view (becomes focus image). 0 states image 10. The Shift+# refers to images 11..20 respectively. You can also set the FI via the top Window sub-menu. When a file is opened for view, it's assigned with an id (can be seen in the status bar). The number keys might have different interpretation upon different app state (see other Hot-Key that follow). There cannot be more than 20 images opened for view at one point (close an image to free a HK slot). [*] Set the ZF to Fit-To-Window. [+] Increase the ZF one step up (zoom-in). Level of increment isn't linear. When ZF is less than 1:1 then the ratio relation is to F2W mode i.e. 0.5 is in proportion to F2W and not full image size. When the ZF is higher than 1, there is a 1:N (while N is some natural) ratio. Please note that one step down from 1:1 is F2W as we wish to maintain 1:N pixel ratio w/o any sub-pixel interpolation (in order to inspect precise pixels). [-] Decrease the ZF one step down (zoom-out). See [+] for further info. Navigation keys (left, right, up, down) Scroll image view (by page intervals) by intuition. Tab / Shift+Tab Switches between open images forward/backwards. In Layer compare mode, toggles the comparison party images. ~ (Above Tab, left to HK 1) Acts as 'back' key for quick-toggling of 2 recent FI images. <x> Close the FI or the image the mouse cursor is on in comparison mode. <X> Close all opened images if in single view mode or the entire comparison party if in Compare Mode. F1 Show the overlay help screen. ESC Generally, aborts any user-action phase. [Back to main index]

Hot Keys: View / Basic analysis

<c> Enter the app into compare mode image collecting phase. Followed by a number HK, you must select only images that have common dimension (width x height). You can compare up to 6 images at once by default (mutable, see Config File section). The ending image should be entered twice (or if 6 is reached then compare mode will start automatically). Irrelevant images selection will be ignored. Re-entering <c> (or ESC) while in collection phase will cancel it and return to the last FI (single view). The right-most caption in the status-bar will be lit with 'C' when in comparison mode. Note that if you're a mouse-fandom, you can select each image from the Window menu one by one (simply replaces the direct HK approach). <C> or <cc> Depending on the current FI (focus-image), will try to auto-collect all opened images that share the FI dimensions. [L] Valid only in Compare mode. Switches the view into Layer mode (L again/ESC toggles back to SBS compare mode). This allows noticing visual changes by quick-selecting different images in the comparison party. Entering HK (1..N) while in layer mode, will select a FI. In the image's tab panel, you will see its left-to-right ordering for HK usage. Hovering the mouse over HK will switch to it, allowing quick catch of visual differences. [G] Activate Grid mode (visible from zoom-factor 5+). Grid mode also enables tracking of a certain pixel. The features status-bar caption will be lit with 'G' when in grid mode. [V] Activate Pixels Value mode (visible from zoom-factor 15+). Will display Hexa/Decimal pixel values depending on the current hexa/decimal view mode (see Hexa display). The features status-bar caption will be lit with 'V' when in pixel-view mode. [H] Toggle the display type of pixels values between Hexadecimal and Decimal (default). The right-most status-bar caption will be lit with a 'X' mark. [T] Toggles Coordinate Tracking mode which draws a 2 lines projecting the X/Y axis. The right-most status-bar caption will be lit with a 'T' mark. [O] Toggles Coordinate Offset display mode in Tab caption. The offset is simply the linear index of a <X,Y> coordinate in an image (logic). Useful when debugging/viewing binary raw data. The right-most status-bar caption will be lit with a 'O' mark. [J] Jump to coordinate command. After entered, the status bar will prompt for your destination coordinate. Syntax is X Y (while the last space serves as "goto" command). You can use reverse indexing (so -1 -1 is the last pixel). Use Tab to iterate all previously "visited" coordinates. 'C' will clear this list. ~ will iterate the list while actually "visiting" the points. 'R' will iterate (and record) all ROI (if active) corner points (CW order, starting at Top-Left). Ctrl-V will paste coordinate that was copied via the Copy-Pixel command. Handy feature to pseudo-bookmark your work locations or find isolated points that are hard to pin-point via the scrolls. [Back to main index]

Hot Keys: Advanced analysis

<r> Activate Ruler mode (resolution depends on current ZF/user config). The features status-bar caption will be lit with 'R' when ruler mode is active. <R> Open the Ruler Config dialog window which remains resident until closed. You can either use Screen Pixels or Image pixels and set the spacing per axis. The Screen Pixels means that the ruler bars will be indented by the display logic pixels no matter the zoom factor. The Image Pixels means that the ruler bars will be indented by the viewed image pixels so if one selects 20 (x/y) then a ruler bar will be set at 0, 20, 40, ... For Image Pixels mode, you can also set a starting offset per axis to start the ruler from which enables aligning data that start at <0,0>. Use "Apply changes" button to test your changes. Ctrl-[R] Toggle between a set of ruler colors. Useful when an image back-ground blends with a ruler bar/text. If in Compare Mode, toggling out-side of an image will toggle the color for all the comparison party (while image 1, the left-most, is the anchor) else it will be selective toggling. [M] Toggle between indent based ruler and matrix based ruler. Ruler mode must be on. This can be used to layout checker board like tiles all over the image to align objects or POI in the image. Mode follows ruler-colors toggling selection model. The features status-bar caption will change the 'R' to 'M' when matrix mode is on. [I] Open the information overlay which holds histogram and statistical data. Refer to Histogram view for further info. The key is context-aware and follows the ruler colors paradigm (see Ctrl-R). <b> Toggle Histogram transparent view on/off. See Histogram view for extra info. <B> Toggle Histogram transparent view shadow affect on/off. Ctrl-[B] Rotate (cyclic order) the Histogram transparent view foreground colors. [A] Adds a beautified decimal values for overlay data. This simply means digits grouping by the conventional decimal 10^3 style (1234 --> 1,234). This is applied on specific set of values that tend to be larger than others in overlay view. [Back to main index]

Hot Keys: Analysis assist actions

[D] Test for difference between 2 images that are viewed in Compare Mode if they share the same image family (RGB, YUV or Gray Y8). The diff-ed image will be opened to the right if there's a vacant image HK slot. Note that if there's an active ROI, only its area will be diff-ed and the rest will remain as is. There are 4 types of diff modes (see Ctrl-[D] for toggling them): all_bin - All pixels are included with binary comparison (equal or not). all_abs_delta - All pixels are included with abs difference (up to 255 difference levels). mask_bin - Only masked-in pixels are included with binary comparison (equal or not). mask_abs_delta - Only masked-in pixels are included with abs difference (up to 255 difference levels). Ctrl-[D] Toggle between the 4 diff modes. The new mode will be displayed briefly in the status-bar. Accessible also from 'Actions/Diff type' menu item. <f> Open the Filter Colors dialog that allows to filter out (mask in) colors or color planes. If in single image mode, the filter will be applied on the FI else it depends on the current mouse cursor position and the extended dialog options. The dialog holds comprehensive guidelines text with examples. Ctrl-[F] Apply the last used Filter on the active image (see <f> for how an image is selected into context). <F> Remove the current active filter from an image (FI). [E] Activate Image Evaluator dialog (see I-Eval). Ctrl-[E] Reapply the last edited I-Eval as is. Very handy for repetitive morphologic operations or advanced image manipulations that are iterative. [Back to main index]

Hot Keys: Generic image operations

<s> Enter Save Image Mode (active selected ROI or entire image if N/A). Then, followed by 1 (Binary), 2 (ASCII-Text), 3 (Text Hexa-dump) and last, followed by 1 - Original packing, 2 - Planner, 3 - Interleave. For developers benefit, it's possible to save also c-style array data (see Config File section). It's also possible to save an image statistics info (see Histogram view section). Note that if the image is more than 8bpp, an option for BE/LE will be presented. Also, as the app is aimed for ANALYSE MODE, it refrains from harming loaded files i.e. it's guaranteed that file are handled in Read-Only mode and no overwriting of data will take place with-out a preceding user prompt. <S> Save (export) the image to PNG RGB-8 format. If ROI is active, then only the ROI will be saved. Ctrl-[S] Toggle the auto-naming mode on/off (when saving an image). When auto-naming mode is on, the application tries to best-match an output file name (by its type, action performed, etc.) but when it's off, a Save File dialog will be prompted upon any 'save' command. <n> Duplicates the current image or the active ROI in case the user is inside its region. When in Compare Mode, the mouse current position directs the selected image to clone / crop. You can access this command also via the Window sub-menu (but you can't duplicate only the ROI in this form). <N> Opens the convert image dialog. This allows a user to convert from any source raw image to any app supported raw format while manipulating its original size / colors. Ctrl-[C] If entered on an image tab, copies its full path / title to the clipboard as text. If entered when inside an image view frame, the image is placed as a RGB24 bitmap. Note that if there's an active ROI, only its area is copied to the clipboard. This key-feature allows a user to use any conventional image viewing program to export the raw image into other formats, if needed. [P] Copy to the clipboard the current pixel coordinate and value. If the cursor position is out-of-image then the FI dimensions are copied (WxH). The copy is state aware so it will be affected from a pixel's view mode and offset display mode. [Back to main index]

Mouse control

General theme Move over images and tabs to handle application interaction. In several features, the image the mouse is over, will become the active context (user interest). When hovering an image (single mode or compare mode), one can notice the status bar info changes accordingly (same goes for tab info). Ctrl + Scroll Zoom in / out. Synonyms of [+] / [-]. Scroll (wheel) Scroll up / down. Shift + Scroll Scroll left / right. Left click on tab X (top-left of the tab) Close the current open image. If in Compare mode, you can hold the Ctrl while hovering the X icon and it will change to O, then, L-Click will remove the image from the comparison party rather than the default close behavior. Left click in tab Show an image histogram + statistics summary. See Histogram view for further info. L-Click again on the tab to close the Histogram overlay. Left click in image First click, selects ROI (Region-of-interest) Top-Left coordinate. Second, selects Bottom-Right coordinate and make the Selection Mode active. If in Compare Mode, all images are selected simultaneously. If you enter Compare mode while party images have different active ROI, only de-selection will have meaning otherwise the behavior is unpredictable (but might be useful to compare different histogram datum). While in ROI 2nd coordinate selection phase, you will see at the status bar the anchor coordinate with the anticipated ROI size, presuming your current position will be final. Right click in image Disables the current active ROI selection and returns to full image view. If you hover an active ROI corner (lit with white filled circle), R-Click will assume you wish to adjust this corner so you will restart your ROI selection while the diagonal point will become the anchor point (so you can re-adjust the current position). [Back to main index]

Histogram view

The histogram view shows an image statistical info with an emphasize on histogram datum. It's key-feature is allowing user browsing of the histogram bins and reflecting a per-channel info. When the overlay is on, all regular user-actions are in order and the info will be updated accordingly. This is specially useful when working with ROI as the current view always reflects the current active ROI, whereas non-active ROI simply displays info for the entire image. Note that when an image is filtered, only the unmasked pixels (visible) are part of the statistics / histogram view datum. User can hover an histogram bin and see its specific count in the channel. This is valid only if the histogram can fit its max 256 width (displayed bins). When this overlay mode is on, each mouse move over an image pixel will display in the tab view its current histogram bin count. Holding Ctrl, while hovering an image pixels, will lit the corresponding pixel bins in the histogram for quick visual tracing of its value (UX). By default, the histogram overlay shows in a white box with coloring per channel. As it might take a considerable amount of screen space, it's possible to work in a transparent mode while affecting foreground color and shadow affect in order to reach max visibility. See the [B] key variants (active only if histogram overlay is visible). The histogram also handles larger than 8bpp images which means that for 16b/32b the histogram might be squeezed in order to give the user a general notion of its characteristic. When pressing <s> (save image) inside the Histogram view, a file with '.stat.txt' extension will be created with full statistics datum (which might compensate over a squeezed histogram data). [Back to main index]

Filter colors

Filtering (masking out) colors can be a very useful tool when one wishes to visually separate the image from a set of colors for statistical analysis or better visualization of specific color range. As filtering is an integrated feature of the app, activating a filter goes hand with hand with other features like Overlay view and grid / pixel value mapping. Note that when a ROI is active, the filter is automatically applied only on its area. You can enter a filter via a dedicated dialog or via the command line (refer to the Command Line interface). Though the dialog itself fully layouts the format, we'll re walk it here for extra clarifications. You supply a filter while the values in the "Enter colors to filter:" edit box are used as a positive filtering (filter-in) i.e. colors entered will be seen while all others are masked out by default so if you just enter nothing (blank sheet), all colors will be invisible. The "Negation color" edit box is used for visualization purpose so one can give a solid color(s) to all masked out (or filtered out) pixels so they can be easily distinguished. Obviously, it's up to the user to select the proper negation color (0 is the default). Good example is YCbCr (or YUV) that uses a shifted chrominance values so 0 for CbCr is actually 128 hence a good negation vlaue might be: 0;128;128. The usage format is quite forward so here it is: - All colors are filtered out by default. - Filter expression parsing is from left to right. - Separate color component by semi-colon(;) and multiple values (per component) by comma(,). - Supply value (8b/16b) as is or a range (separated by dash -) e.g. 7, 10-200, 30-31, 2000-5000. Note that we don't support 32b filters as we do care a bit for performance :) - Precede with ^ to negate the values (i.e. exclude out) e.g. 0-100,^99 will filter only pixels ranged [0,100] excluding 99. - Put * in single or range to note all colors (in range it means below and above). - Leave empty component (like ;;) to sign mask-out all (same as ^*). - If single component is given for 3 components image then it's duplicated for all 3. Common examples: Gray(Y8) : 30,45-100,^60-70 This will show all luma values that are of 30, [45,100] but not including [60,70] RGB 48bpp : 1000-6000; *,^0-1024,512; *-999, 2001-* This will show all Red in [1000,6000] range and in Blue all but [0,1024] while 512 is shown and in Green all values that range [0,999] and [2001,16535] Dialog extended control (via check box items):
  • Apply on all images of the same family Relevant when working in comparison mode. You can choose to apply the filter on all images that share the left-most (no. 1 in the group, or FI) core properties (image base type and no. of components).
  • Apply to a new image Sometimes it's useful to apply the filter and then compare it or simply refrain from touching the current image state. This will simply create a new image (assuming there's a free HK) and will apply the filter on it.
  • Pixel is valid if all 3 components are in range For 3 components (channels) images, it's sometimes essential to filter the pixels as a group and not per channel. The best way to understand this semantic is via an example: Suppose you have a RGBx8 image and you write a filter of this sort [100-128,200-*,*-80] (and negation color is 0) then w/o checking this option, a pixel like <60, 210, 90> will be filtered in (with a value of <0,210,0>) but it might be that the original intuitive meaning of that filter was to exclude such pixels so when checking this option, such pixels will be excluded and pixel like <101,255,50> will be visible.
  • Separate to image per component (only on focus image) Quite straightforward, a convenient (and fast) way to separate an image channels or to apply the filter per color plane. For quick channels speration, just write *. Note that you must have at least 3 available HK slots for this option to be available.
  • Example that shows how to apply a more complex filter and how the grid is affected by filters
    Filter dialog
    Resize with tiling example
    [Back to main index]

    Convert new image

    Though conversion is quite a straightforward operation, its more advanced options does require a bit of clarification / elaboration. Use this dialog to convert your current RAW format to any (app supported) other format. The "Select from menu" support roughly around 40 conversion types and it suits most common needs but if you require a more fine-tuned conversion, use the "Direct" expression to manipulate the output components / format as you wish, just follow the Formats file syntax. Example: Suppose you're working with an embedded device that layout the YCbCr plane with packed 422 in the form UYVY and 16bpp so as the menu doesn't layout this option you will write I,UYVY,16 (or -16) and that's it. The direct expression supports more than 200 RAW format styles (due to its flexible component ordering scheme). The color transform allows you to specify a specific flavor for your color space conversion, else the app default is used. There's not much to add here but that you should know what you're doing, a bit of mathematical / image analysis background will serve you right here... Resize menu options:
    • Enable resize When not enabled, the output will share the source image dimensions.
    • New size Enter here the destination size. Note this is only image resizing, not any form of scaling. Put the width and height in the form: width;height. For UX, you can put here any kind of expression that the Image Evaluator can handle while 'w' and 'h' serve as variables for the source width and height. This gives you the flexibility to work with complex dimensions that have sophisticated ratios to the source image. If you use expression like w*1.5;h*2 you're assured this will work for all source dimensions and not tailored to a specific image.
    • Positioning base offset Enter here X,Y that have context-aware meaning: - If the output will be larger than the source in both dimensions then this refers to the offset in the output that the source positioning will start at. - If the output is smaller (or partially smaller) than the source then this offset refers to the start position in the source image that we'll start taking pixels from. Note that depending on the above explained context, you can use reverse indexing if it suits you better (-1,-1 is the images source/output last pixel).
    • Tiled source on output If set, then a repetitive pattern of the source image will be layout on the output, yielding a tile effect (note that the base offset will have its regular affect here) so this can be handy way to fill the entire output with the source pattern. When not set, irrelevant sections on the output will be black (color-space depended).
    • Original size button Helper button to set the source size in the new size edit box.
    Example that shows how to take your "little prince" from a JPEG (RGB) image and by taking the ROI of his face and then resizing and converting into gray-scale, you get a passport like image (and 9 times your original prince...)
    Filter dialog
    Resize with tiling example
    [Back to main index]

    Image Evaluator (I-Eval)

    The I-Eval is used to enhance the basic analyzing feature into a flexible and comprehensive image manipulator for dedicated goals. It serves as a replacement for writing a dedicated code (in your favorite HL/script language) or for quick image manipulating that can further complement the analyzing procedure. The main functionality of the I-Eval is iterating an image(s) pixels in raster order and allowing to output any value in order to create a new 1/3 channels (components) image. This is achieved by writing a c-like expression that is iterated per pixel with the proper context. You can use it to swap channels data, transform an image, mask, average and anything that can cross your mind.

    For the benefit of clarity, all noted expressions will be enclosed with {...} which is non-mandatory if you wish to apply single expression (refer to multi I-Eval notes).

    The best way to understand its usage is by examples: Suppose you have a comparison party of 2 gray images and the regular diff action is too "binary" for your task and you need it to count as difference only if the delta is larger than 4, for this you will write:
    
    { (abs(i2-i1) > 4)*255 }
    
    
    Suppose you have now RGB image with the same problem and you wish to create a single diff image, then:
    
    { (abs(i2c1-i1c1) > 2 || abs(i2c2-i1c2) > 2 || abs(i2c3-i1c3) > 2)*255 }
    
    
    Note that because the input is 3-channels, you must select the 'Forced single' option else you will get a 3 channels output (on that further).

    Base syntax and guidelines:

    Dialog GUI options (I-Eval control parameters)

    • Out of image index range value If you use expression like i2[x-20,y] then it's obvious that for the 20 first iterations in each row, you will point to index in the image that isn't legit. For that, you can supply a value (or per channel by using ';') that will be auto-set whenever the offset in the image goes out-of-range. Default is 0.
    • Output replaces image By default, a new image will be created as an output, appended in a new valid HK. You may, however, wish to replace one of the inputs (done at iteration end, not in-place so input is persistent) so you just enter here an index (1..N) while empty or 0 state a new HK. When you invoke several I-Eval expressions in a pipe, you may wish to direct each intermediate image evaluation to a different output so if you have, let's say, 3 consecutive I-Eval and 4 input images, you may write '2,1,3' so after the first I-Eval, image 2 will be replaced with the output and so on. If you supply less indexes than the no. of I-Eval, then the last is appended to fill the gap (i.e. for the above example, '2,1' is the same as '2,1,1'). You can assign 0 as a last entry to state a new image output (recall you can't access it in intermediate operations as it's not part of the comparison party). Note that you can't change input image no. of channels when using piped I-Eval i.e. if you wish to output over image 2 but your expression presume 1 ch. data then it will raise a parse error or simply duplicate the channels.
    • Apply only on ROI area In case there's an active ROI, you can choose to apply the I-Eval on its region which can help reducing evaluation time and even yield smart scale/morph image manipulations.
    • Output channels Supported raw images have 1 or 3 channels (components). As such, you may influence the I-Eval no. of output channels. If you select 'By context' then you wish that the engine will analyze the input expression and if the input image has 1 ch. then the output will have 1. If the input has 3 ch. then the output will have 3. If the expression holds per-channel expression (like {i;i;i}) then you wish to create 3 ch. output. All 3 channels output are formatted as planner RGB by default unless the "Use YUV for 3 ch." is checked. Still, there are cases where the input is holding 3 ch. but you wish to evaluate a single channel output, for those cases, you should select the 'Forced single'. Note that trying to force a single output on a 3 comp. expression is considered an error.
    • Output BPP You can control the BPP (bits-per-pixel/bits-depth) of the output image. This is very useful when you wish to expand or reduce (quantize) an image datum. Selecting auto will use image 1 as anchor (and thus forcing all others to align with it, no matter their actual BPP). Quick example is gradient image: Suppose you have 8 BPP luma image and you wish to create a gradient image for the x axis (frequency domain), then { i[x+1,y]-i } should give that but a negative value like (6-100 = -94) will be clipped to 0 so if the output is 16 BPP you can write something like {i[x+1,y]-i + 255} and all values will range [0,510].
    • Expression(s) evaluation error list As its name states, here you will see a report for input or evaluation errors that might occur due to complexity of the entered expressions (syntax, math errors, etc.).
    • List of saved I-Eval expressions This serves as a pseudo-macro generator. Many expressions are very complex and instead of saving them in your favorite text editor, you can save them here and give them a proper name. You may save here even piped expressions ({...} {...} ...). Suppose you have an image quantizer expression like {(i+2^4) >> 5} so a good name might be '3bit Quantizer' and so on. Note that each double-click (select) on a list item will concatenate it to the currently edited I-Eval expression with a {$I-Eval name$} markup. R-click on a selected name will put the I-Eval expression itself {...} so you may edit it before submission. If you save over an existing name and overwrite w/o prompt isn't checked, you'll be prompted to overwrite it. Use 'Delete selected' to delete unused items. You can save the same expression with different names, it's completely a user's choice. All saved expressions are saved under 'ria.ieval.txt' (default, see Config file) in plain text form with <name> ... </name> style. Feel free to modify it outside if more convenient.
    • Sorted list / Custom list To assist the saved I-Eval list organization, you can choose to view the items in sorted or custom order. The custom (default, the button will show switch to "Sorted list") allows you to set the data as you see fit and you can use the Up/Down arrow buttons to customize a different layout and, for an example, put more frequently used items higher or by pseudo-logical groups. The sorted (the button will show switch to "Custom list") allows you to view the list in lexicographic (A-Z) order. Do note you can't edit the list order (obvious, as it's sorted...). One note regarding the file that stores the list - it always reflects the custom order so you can easily manipulate it with an external editor by your choice.
    • Expanded / Original expression For complex expressions, if the parser reported some error or you wish to see expanded nested expressions, toggle between this views to fine-tune your edited I-Eval or pin-point a parsing error.
    Example that shows how to create X,Y gradients and then use these 2 gradient images as a mean to create a luma mask of the original image (in our case, that the 2 gradients are close to one another)
    Filter dialog
    Resize with tiling example

    Expression strength

    • The expression can be written in a c-like form while incorporating many standard math and logic functions / operands. All follow standard operator precedence.
    • Any intermediate calculation is done on 64b values, may them be DP (double) or integer. This requires extra clarification: No matter the images (or selected) bits-depth, you are assured all intermediate calculations are performed with max flexibility and only in the end, the values are clipped to their proper BPP limits.
    • The final value is always clipped to the output BPP range and any DP values are truncated (and not rounded so use round(x) if you require a rounded value).
    • The math constants e (2.71...) and pi (3.14...) are a 64b constant variables.
    • Functions that have domain constraints, will raise an error for invalid input.
    • You can use 0xNNNN to sign hexa-decimal numbers (0x1F) and NNNNb to sign bin (101b).
    • Logic operandsOutput yields 0/1
      || Or
      && And
      ! Not
      Comparison operandsOutput yields 0/1
      < Lower than
      > Greater than
      <= Lower than or equal
      >= Greater than or equal
      == Equal
      != Not equal
      Bitwise operandsInteger only
      & And
      | Or
      ~ Complement
      |^ Xor
      >> Shift right, signed
      << Shift left
      Basic algebra
      + Addition
      - Subtraction
      * Multiplication
      / Division Note it's context aware i.e. if the expression is integer then it will use an integer divider (like truncation) else the floating-point one
      ^ Power of (63, 4-(1/3), ...)
      % Integer modulo, iso-c semantics
      TrigonometricInput is in radians unless stated otherwise
      sin(x) Sine
      cos(x) Cosine
      tan(x) Tangent
      atan2(y,x) Arctangent (by quadrant)
      rad(x) Radian of 360 deg. angle
      deg(x) Degree (-2Π.. 2Π)
      General math
      sign(x) Return -1 if x < 0, +1 if x > 0, else 0
      exp(x) Same as ex. Choose your flavor
      log(x) Natural logarithm (e)
      log10(x) Decimal-base (10) logarithm
      logb(b,x) B-base logarithm (e.g logb(2,8) = 3)
      abs(x) Absolute value of x (noted |x|)
      sqrt(x) Square-root. Same as x0.5 but uses a dedicated function.
      dist(x,y) Distance of <x,y> from <0,0>. Named radius in polar coordinates
      max(a,b) Maximum of a and b
      min(a,b) Minimum of a and b
      bits(x) No. of bits required to represent |x|. Can be float but reflects only the integer part
      Integer only in/out
      bool(x) Evaluate x to be either 1 (if not 0) or 0
      fact(x) Factorial of x (x!). Bounded by 64b val
      binom(k,n) Binomial coefficient (same as k-selection)
      Conversion
      floor(x) Rounds x downward. Result is integer. E.g floor(3.2) = 3, floor(-5.1) = -6
      ceil(x) Rounds x upward. Result is integer. E.g ceil(3.2) = 4, ceil(-5.1) = -5
      round(x) Rounds x. Result is integer. E.g round(3.2) = 3, round(-5.1) = -5, round(-5.6) = -6
      double(x) Converts x to double. Useful for division (3/double(x), while x = 2)
      The best way to understand how I-Eval can be useful is by several common examples. Example 1 Blending 2 images while image 3 serves as alpha map (assuming 8bpp values).
      
         round((i3*i1 + i2*(255-i3))/255.0)
      
      
      Example 2 Put image 1 over image 2 if image 2 values are below a threshold of 5.
      
         (i2 >= 5)*i1 + (i2 < 5)*i2
      
      
      Example 3 The famous fish-eye effect in a center of image, radius of 100 and curvature factor of 0.01. Let's assume the image is at least 100x100. The rest remains as is. The general way to do it is using polar coordinates transform and defining some smooth factor (s) as 'rad/log(curvFactor*rad+1)' so the new radius becomes '(e^(rad/s)-1)/curvFactor', expanding all yields:
      
         (dist(x-w/2, y-h/2) <= 100)*i[
         w/2+cos(atan2(y-h/2,x-w/2))*(exp(dist(x-w/2, y-h/2)/(100/(log(100*0.01+1))))-1)/0.01,
         h/2+sin(atan2(y-h/2,x-w/2))*(exp(dist(x-w/2, y-h/2)/(100/(log(100*0.01+1))))-1)/0.01]+
         (dist(x-w/2, y-h/2) > 100)*i
         
      
      Note that if you use it in several scenarios, you can use macros and make it more readable (like ang = atan2(y-h/2,x-w/2)). Example 4 Apply white-balance and black level. We assume the WB value is 220 and BL is 15.
      
         round(i*(255.0/220))+15
         
      
      Example 5 Making a mask of a key-color value range (say 4..8).
         
         255*(i >= 4 && i <= 8)
      
      
      Example 6 Simple 3x3 averaging-like kernel-based filter (rounded final value).
         
          round((c[x-1,y-1]*1+c[x,y-1]*2+c[x+1,y-1]*1+
          c[x-1,y]  *1+c       *3+c[x+1,y]  *1 +
          c[x-1,y+1]*1+c[x,y+1]*2+c[x+1,y+1]*1)/14.0)
      
      
      Example 7 Using the pipe feature to create a gradient X and Y images. We assume we have 3 images in the group and only image 1 is immutable and our output overwrite sequence will be 2,3 and output is 16bpp (input is gray-8bpp, 2, 3 are gray-16bpp).
      
         {i[x+1,y]-i + 255} {i[x,y+1]-i + 255}
      
      
      If you wish to see the visual outcome of the gradients, you can try the following in order to "stretch" the 16b values:
      
         {(i[x+1,y]-i + 255) << 7} {(i[x,y+1]-i + 255) << 7}
      
      
      Example 8 Converting RGB into HSV model. In our example we'll calculate Hue, Chroma and Value (a.k.a M) respectively. (R,G,B) = (c1,c2,c3)
         
         atan2(0.5*sqrt(3)*(c2-c3), 0.5*(2*c1-c2-c3)) ;
         dist(0.5*(2*c1-c2-c3), 0.5*sqrt(3)*(c2-c3))  ;
         max(max(c1, c2), c3)
      
      
      Note that this will yield HSV values while the visual side-effect will be undefined. Example 9 Simple image rotation around the center by 30 deg. (invalid areas will be black).
      
         i[w/2+(x-w/2)*cos(pi/6) - (y-h/2)*sin(pi/6), h/2+(x-w/2)*sin(pi/6) + (y-h/2)*cos(pi/6)]
      
      
      Example 10 Creating a cropped (no interpolation) Bayer RGGB image. Output is forced 1.
         
         (x % 2 == 0 && y % 2 == 0)*c1 + 
         ((x % 2 == 1 && y % 2 == 0) || (x % 2 == 0 && y % 2 == 1))*c2 + 
         (x % 2 == 1 && y % 2 == 1)*c3
      
      
      Example 11 Converting Bayer RGGB to RGB. Very useful for sensor raw images.
      
         (x % 2 == 0 && y % 2 == 0)*i + (x % 2 == 1 && y % 2 == 0)*(i[x-1,y] + i[x+1,y])/2 +
         (x % 2 == 0 && y % 2 == 1)*(i[x,y-1] + i[x,y+1])/2 + 
         (x % 2 == 1 && y % 2 == 1)*(i[x-1,y-1] + i[x+1,y-1] + i[x-1,y+1] + i[x+1,y+1])/4 ;
         ((x % 2 == 0 && y % 2 == 0) || (x % 2 == 1 && y % 2 == 1))*(i[x-1,y] + i[x+1,y])/2 +
         ((x % 2 == 1 && y % 2 == 0) || (x % 2 == 0 && y % 2 == 1))*i ;
         (x % 2 == 0 && y % 2 == 0)*(i[x-1,y-1] + i[x+1,y-1] + i[x-1,y+1] + i[x+1,y+1])/4 +
         (x % 2 == 1 && y % 2 == 0)*(i[x,y-1] + i[x,y+1])/2 + (x % 2 == 0 && y % 2 == 1)*
         (i[x-1,y] + i[x+1,y])/2 + (x % 2 == 1 && y % 2 == 1)*i
         
      
      Obviously, this expanded expression is a bit hard to follow so a good approach will be to define the 4 Bayer pixels (and operands) as:
      
         p00 = (x % 2 == 0 && y % 2 == 0)
         p01 = (x % 2 == 1 && y % 2 == 0)
         p10 = (x % 2 == 0 && y % 2 == 1)
         p11 = (x % 2 == 1 && y % 2 == 1)
         avrLR = (i[x-1,y] + i[x+1,y])/2
         avrTB = (i[x,y-1] + i[x,y+1])/2
         avrD4 = (i[x-1,y-1] + i[x+1,y-1] + i[x-1,y+1] + i[x+1,y+1])/4
         
      
      So the above long expression can be written as:
      
         $p00$*i + $p01$*$avrLR$ + $p10$*$avrTB$ + $p11$*$avrD4$ ;
         ($p00$ || $p11$)*$avrLR$ + ($p01$ || $p10$)*i ;
         $p00$*$avrD4$ + $p01$*$avrTB$ + $p10$*$avrLR$ + $p11$*i
      
      
      By using these 7 macros, you can easily define any Bayer sub-pattern. Example 12 Image negative. Same as CMY (suits both 1/3 channels image).
      
         255-i
      
      
      Example 13 Simple downscale by a factor of 2 with bi-linear interpolation. We assume there's an active ROI from <0,0> with size (w/2)x(h/2) and that we're working solely on the ROI area.
      
         (i[x*2,y*2] + i[x*2+1,y*2] + i[x*2,y*2+1] + i[x*2+1,y*2+1])/4
      
      
      Example 14: This will demo a very complex example of applying the Zhang-Suen thinning algorithm on binary (or luma-based images). As the algorithm is iterative, we'll create several macros to assist us in the process. Recall you can edit by yourself the I-Eval saved expressions file so let's assume we have there (p2 above center point, going CW):
      
         p2 = (c[x,y-1] != 0), p3 = (c[x+1,y-1] != 0), ..., p9 = (c[x-1,y-1] != 0)
         
      
      Now we can use them as macro-blocks and create 2 iterations:
      
         ZSAlg_A = 
              ($p2$ == 0 && $p3$ == 1) + ($p3$ == 0 && $p4$ == 1) + 
              ($p4$ == 0 && $p5$ == 1) + ($p5$ == 0 && $p6$ == 1) + 
              ($p6$ == 0 && $p7$ == 1) + ($p7$ == 0 && $p8$ == 1) +
              ($p8$ == 0 && $p9$ == 1) + ($p9$ == 0 && $p2$ == 1)
         ZSAlg_B = $p2$ + $p3$ + $p4$ + $p5$ + $p6$ + $p7$ + $p8$ + $p9$
      
         ZSAlg_iter0_m1 = ($p2$ * $p4$ * $p6$)
         ZSAlg_iter1_m1 = ($p2$ * $p4$ * $p8$)
         ZSAlg_iter0_m2 = ($p4$ * $p6$ * $p8$)
         ZSAlg_iter1_m2 = ($p2$ * $p6$ * $p8$)
      
         ZSAlg_iter0_marker =
              ($ZSAlg_A$ == 1 && ($ZSAlg_B$ >= 2 && $ZSAlg_B$ <= 6) && 
              $ZSAlg_iter0_m1$ == 0 && $ZSAlg_iter0_m2$ == 0)*255
         ZSAlg_iter1_marker
              ($ZSAlg_A$ == 1 && ($ZSAlg_B$ >= 2 && $ZSAlg_B$ <= 6) && 
              $ZSAlg_iter1_m1$ == 0 && $ZSAlg_iter1_m2$ == 0)*255
              
      
      We'll define the mask while assuming it's referring to image 2
      
         ZSAlg_marker_mask = 0*(i2 != 0)+i*(i2 == 0)
         
      
      Now, the final single iteration will be consisted of the above 3 building blocks:
      
         ZSAlg_iter = 
              {$ZSAlg_iter0_marker$} {$ZSAlg_marker_mask$} 
              {$ZSAlg_iter1_marker$} {$ZSAlg_marker_mask$}
              
      
      All we need is to duplicate our source image using <n>, enter comparison mode, put $ZSAlg_iter$ as I-Eval and set the output replace sequence to be 2,1,2,1 and we got ourself a mean to inspect a single iteration of this nice thinning algorithm. Later, using Ctrl-[E], you can further iterate the algorithm steps until reaching a non-changing image. You can create 2 copies of your original image and put the original as a 3rd panel and see how it changes progressively (or create a diff image and monitor the thinning steps). Minor notes regarding the evaluation process: As processing complex expressions is very exhaustive (cpu-wise), several optimizations are done in order to evaluate it faster. You should know that the expression is being pseudo-compiled into a lower level notation and that redundancies in calculation are omitted by pre-evaluation of constant values and caching of already evaluated values. [Back to main index]

      Formats file for RAW images

      The file is used to open a raw image file (assuming its explicit info isn't given via the command line) with varying possible string patterns (using regex). When a new file is opened (via drag-and-drop, command line argument or menu), the groups (noted as format_group) in the file are iterated in linear order (which means higher priority should be placed at the file's top) and a path that will "pass" all the patterns criteria will be delegated to its proper image format handler. Note that a pattern passes only if it's a complete match (and not partial) and that all the regex are case insensitive. Also, all regex expressions start with [ and end with ] which aren't part of the regex expression itself: e.g. [.*\.(yuv)$] will pass all files that end with .yuv (like nice_face.yuv). Use ';' at beginning of a line to state a comment. The used regex engine is based on POSIX/TRE (see C++11 and TR1 references). As regex tend to be delicate, you can use the format file logger to identify loading errors. Syntax: <format_group> file_pattern = [regex] width = [regex],$N or some fixed value height = [regex],$N or some fixed value format = [regex],[A],[offset],[packing],[layout],[bpp] format = [regex],[A],[offset],[packing],[layout],[bpp] . . . </format_group> Format Group syntax is consisted of: - file_pattern The first order criteria requires that the file (should be plain file name) will match this rule. - width Place a regex pattern that will direct how to "capture" the image width, after the regex (quoted with [] which aren't part of the regex expression itself) put a comma (,) and note the regex params to catch using $ and a suffix digit (1-based, up to 9). This is non-mandatory ($1 is the default). You can set constant values like 640 ('width = 640') to force a specific size. e.g. width = [.*wh_(\d+)_\d+_.*]. This will match a file name that has 'wh_' somewhere in it followed by 2 integer numbers (separated by '_') and the width is the first of the 2 numbers. File name as an example foo_img_wh_1280_720.img, img_wh_100_80_0050.raw, etc. - height Follows width rules but is used to capture the image height. e.g. height = [.*wh_\d+_(\d+)_.*] - format Signs the proper image file data parsing. Syntax: [regex], <A?>, <ofs?>, <P|I|PI>, <((R|G|B)|(Y|U|V))+{1,3}>,<?-(8|16|32)> [regex] The pattern to match the format against. [A] Signs that the input itself comes in a ASCII text format with a CSV layout. For user's convenience you can place any white space, comma or semi-colon as a CSV separator. Non-mandatory option that is useful for files created by IP tools like Matlab and the likes. For the special case of gray-scale image, it's possible to give unknown image dimensions by setting them as 1 and if the input image will carry a matrix data form (NxM) then the dimension will be auto-detected. [file offset] Offset to start loading from in a file. Negative values state a reverse offset i.e. from file's end. This is an optional argument and can be omitted. Note that if it is present, it's user responsibility to know what he's loading as the app cannot match the format against its size for a sub-image loading. [packing] P stands for Planner (the components are layout one after the the other). I stands for Interleave. PI stands for Planner then Interleave (currently, only used with Semi-Interleaved YUV420 format). [layout] Planner: - RGB, 3 layout tokens (separated by comma) are given (any variant of RGB i.e. RGB, RBG, BRG, BGR, GBR, GRB). - YUV, 1 or 3 layout tokens (separated by comma) are given (any variant of YUV). If 1, then it's usually Y-Only format (gray/luma). e.g. YY,U,V (YUV422 in planner layout). Interleaved: - RGB, 1 layout token is given, specifying the components to interleave (left-to-right, in any order). There's no support for RGBA (alpha channel) as it's uncommon in raw data. - YUV, 1 layout token is given, specifying the components order for the first N components (resembles Y:Cb:Cr packing). The layout is given in 1 group of up to 8 consecutive components. Note that as YUV format dictates, the ratio between Y,U and V count must be dividable by 2 (1 is also legit). Planner-then-Interleaved: - Currently, only Semi-Interleaved (a.k.a Semi-Planner) YUV420 format is supported i.e. write as YYYYUV (or YYYYVU). [bits-per-component] Signs the bits-depth of each component (currently, only 8, 16 and 32 bpp are supported). If the value is given with a minus sign (relevant only for 16, and 32) then the byte order of each component will be reversed (big-endian as opposed to x86 native little-endian). Note that you can supply as many formats as desired. Keep in mind the matching order is linear and the first to match wins (still, if the file internal data will be a miss, it will skip to the next format). Usage tip: For those who find the syntax a bit complex, you can find in the default format's file RawImageAnalyser.ini several standard examples that use some basic reg-ex commands. [Back to main index]

      Config file description and usage

      The configuration file exists to enhance the app user control over GUI themes and other more advanced functionalities. It's a non-mandatory file but if exists, it should be named 'RawImageAnalyser.ini' and resides at the application's execution path. As the app doesn't touch the Registry, you can put the app where you wish (fire and forget style).
      Short descriptionDefault
      guiAffects GUI related properties like colors and view modes
      ruler_color Set a ruler color listred, white
      ruler_font Set a ruler fontArial, 16, 12
      ruler_type_matrix Set the ruler mode to be indent/matrix0
      tab_font Set the tab fontArial, 16, 12
      tab_color_fg_bg_hl Set the tab colorwhite, <150;30;20>, <200;70;0>
      pixel_display_base Pixel value base dec/hexdec
      value_comma_decorate Decorate decimal values comma0
      histogram_max_height Max histogram height (in pixels)80
      histogram_transparent Histogram transparent background0
      histogram_transparent_fg_color Histogram transparent FG colorwhite, black
      histogram_transparent_shadow Histogram high contrast shadow0
      def_zoom Initial app zoom-factor0
      ruler_mode Initial app ruler mode0
      grid_mode Initial app grid mode0
      pixel_value_mode Initial app pixel value mode0
      imageAffects image manipulation or semantic of action taken on images
      trans_yuv_to_rgb YUV to RGB color transformITU-R BT.2020 (JPEG)
      trans_rgb_to_yuv RGB to YUV color transformITU-R BT.2020 (JPEG)
      diff_type Initial app diff typeall_bin
      systemAffects app behavior and path related options
      work_path App log files pathExecution path
      format_file_path Path of RAW formats fileRawImageAnalyser.fmt
      ieval_file_path Path of saved I-Eval listria.ieval.txt
      ieval_load_saved_startup_only Load I-Eval list only on init0
      reload_dialogs_edit_history Reload previous sessions edit boxes history0
      max_comparison_party Max allowed images to compare6
      ignore_file_extern_modify Ignore file modifications0
      auto_file_naming Auto file naming when saving1
      app_close_prompt Prompt the user when quittingnew_created_image
      max_process_threads Max processing worker threads0 (unlimited)
      auto_check_updates Auto check for app new versions1
      developerDesigned for debugging and more advanced verbose info
      debug_load_format_log Log load RAW formats process0
      debug_batch_error_log Log batch run-time errors0
      log_app_msg Log app actions / errors0
      save_image_text_hex_c_array Save hexa-text as C array0
      force_thread_per_core Force thread per-core0
      favor_low_mem_over_speed Reduce memory usage in trade-off of performance0
      dialog_convertAffects dialog 'Convert raw' initial controls state
      typeyuv444, yuv422, yuv420, gray, rgbgray
      packingplanner, interleaveplanner
      bpp8b, 16b, 32b8b
      little_endBoolean1
      custom_color_trans_onBoolean0
      def_trans_c1String
      def_trans_c2String
      def_trans_c3String
      resize_onBoolean0
      def_resize_sizeString
      def_resize_pos_ofsString
      resize_tiled_onBoolean0
      dialog_filterAffects dialog 'Filter colors' initial controls state
      def_filterString
      def_negString
      apply_to_allBoolean0
      apply_to_newBoolean0
      all_3_must_passBoolean0
      separate_compBoolean0
      dialog_ievalAffects dialog 'Image evaluator' initial controls state
      def_ieval_exprString
      def_out_of_range_valString
      def_output_overwriteString
      out_replace_imageBoolean0
      apply_on_roiBoolean0
      output_channelscontext, context_as_yuv, singlecontext
      bppby_input, 8b, 16b, 32bby_input
      overwrite_saved_ievalBoolean0
      compare_mode_auto_newBoolean1
      dialog_openAffects dialog 'Open raw' initial controls state
      def_widthString
      def_heightString
      typeyuv444, yuv422, yuv420, gray, rgbgray
      asciiBoolean0
      packingplanner, interleaveplanner
      bpp8b, 16b, 32b8b
      little_endBoolean1
      def_offsetString
      dialog_rulerAffects dialog 'Ruler config' initial controls state
      crd_screenScreen coordinate initial data100, 100
      crd_imageImage coordinate initial data10, 10, 0, 0
      cfg_typescreen, imagescreen
      dialog_file_modifyAffects dialog 'File modify' initial controls state
      try_relaod_same_file_cfgBoolean1
      [gui] ruler_color Default: red, white Set a ruler color (up to 8). Set color by selecting either from a predefined values or give some RGB value (each component should be in [0,255], e.g. <128; 0; 255>). When entering RGB tuples, avoid putting space between values i.e. <100;80;60> and not <100 ; 80; 60> or variants. Values can be given also in Hexa or mixed form e.g. <0xff,0x80,255>. Predefined color values are: black, silver, gray, white, maroon, red, purple, fuchsia, green, lime, olive, yellow, navy, blue, teal, aqua, orange ruler_font Default: Arial, 16, 12 Set a ruler font (name, size normal, size smaller). If the font name have spaces, use '_' (underscore) to sign word separator. Note that if normal size is given but smaller size isn't, we presume it's 0.75 of the normal size. ruler_type_matrix Default: 0 Set the ruler type to be either indent (0) that shows small bold bars to the image's top-left or matrix (1) that will set a dotted matrix all over the image to sign the rulers position (very good for objects alignment). tab_font Default: Arial, 16, 12 Set a tab font (name, size normal, size smaller). If the font name have spaces, use '_' (underscore) to sign word separator. Note that if normal size is given but smaller size isn't, we presume it's 0.75 of the normal size. tab_color_fg_bg_hl Default: white, <150;30;20>, <200;70;0> Tab color tuple: Foreground, Background and Highlight colors. pixel_display_base Default: dec Set either to dec / hex (or base notation 10/16). value_comma_decorate Default: 0 For better UX, you can decorate large values (decimal only) with conventional comma grouping (1234 --> 1,234). Doesn't affect any text file output. Mutable also via the View menu. histogram_max_height Default: 80 For histogram (tool-tip) view, values range: [50,120]. histogram_transparent Default: 0 It's possible to make the histogram overlay mode with transparent background so it will be less intrusive by covering image data. When set to 0, it will use the opaque mode with white rectangle and with more visual context (different data colors for different channels). histogram_transparent_fg_color Default: white, black When working with transparent histogram background mode, you can rotate the visual foreground color (fixed for all datum) which can help dealing with blending colors. Note that the bar (bin indicator) vertical line is always displayed with either white or black color, depending on the selected color contrast (the app always aims to use the color with the highest luminance contrast). You can set up to 6 colors. histogram_transparent_shadow Default: 0 When working with transparent histogram background mode, you can add a high contrast shadow (white or black, depending on the fg color) that can help emphasizing the text even if blended partially with the background. def_zoom Default: 1.0 Startup zoom-factor, 0 for Fit-To-Window. Range: [0.25, 100]. ruler_mode Default: 0 Supply app startup modes for Ruler view (active or not). grid_mode Default: 0 Supply app startup modes for Grid view. pixel_value_mode Default: 0 Supply app startup modes for Pixel Value view. [image] trans_yuv_to_rgb trans_rgb_to_yuv Default: ITU-R BT.2020 (JPEG) Supply user-defined color 3x4 transforms s.t. 3 first components per row are some double and the last is an integer offset (-255..255). The user may still defer these transformations via dialog menus or batch command line. diff_type Default: all_bin Select from this set: all_bin, all_abs_delta, mask_bin, mask_abs_delta xxx_bin state that the difference result is either 0 or 1 (255) xxx_delta state that we perform ABS(A-B) (with a saturated value of 255). In all/mask_xxx state we refer to the all image or just to non-masked pixels respectively. [system] work_path Default: Application execution path Directs the app where to save log files. See [developer] section for further info. format_file_path Default: RawImageAnalyser.fmt (at local path) Specifies the path / file name of where the RAW format loader rules are managed. Do note that if only a file name is supplied, the app will first try and load the file from the local path and then from the execution path. This is done deliberately to enable flexible positioning of RAW format file in different folders, as an example. ieval_file_path Default: ria.ieval.txt (at local path) Specifies the path / file name to load/store the I-Eval (see Image Evaluator) saved expressions. ieval_load_saved_startup_only Default: 0 When accessing the I-Eval dialog, you can select if the saved I-Eval list will be loaded per dialog initialization or only at app's startup phase. As the saved I-Eval file is a simple text file, you can edit it freely outside of the app so if this is set to 0, you can "refresh" the list by re-entering the dialog. If you prefer less file access operations, set this to 1. Note that when set to 0, per dialog instance, you load on initialization and save it back to the file (after modifications) when the dialog is quited (unless user canceled or the applied I-Eval raised an error). reload_dialogs_edit_history Default: 1 Reload from RawImageAnalyser.dat a history of all drop-down edit boxes (up to last 40 per edit-box). The file is a simple pseudo-ini file and must reside in the app execution path. max_comparison_party Default: 6 Set max allowed images to compare (2..8). This might be handy if you wish to use the 'cc' key to quickly select the matching group and you need to push up your upper limit (to avoid app error). ignore_file_extern_modify Default: 0 Ignore external file modification events. As the app acts as an image observer (immutable) and not manipulator, only outside modifications can occur. auto_file_naming Default: 1 Should the app upon save, decide the file name by its context automatically. If 0, the user will be prompted for a file name each save. app_close_prompt Default: new_created_image When exiting the app, should it prompt the user, allowing him to forfeit the action? You have 3 options here: never - quits w/o prompting) always - prompt, no matter what was done new_created_image - in case the user has created a new image (duplicate or convert). max_process_threads Default: 0 The application is able to distribute work among logic cores when facing complex image operations like diff, filter, convert and I-Eval (all under Actions menu). You can set up to 32 worker-threads and let the app/OS use them as it sees fit. Set to 0 if you wish to use max available logic cores. If you set a value like 6 but you have only 4 logic-cores(hyper-threaded are included) then the app will use only the max available (as using more will simply deteriorate the performance due to thread context switch overhead). If you for some reason, prefer to eliminate any thread spawning, non-soever, set the value to -1. This will also prevent you from canceling long operations. Note that when you set a value 0..32 you will see a progress bar when a computational / long operation is using the worker-thread pool to accelerate work. auto_check_updates Default: 1 If set, when the app will start, it will check in the background for new versions. If not set, the user needs to explicitly visit "Help/Check for updates..." menu. Do note that in batch non-gui mode, this setting is ignored (no checking is done). [developer] debug_load_format_log Default: 1, ria.fmt_log.txt When opening some RAW image files, you can log the traces that the app "open" flow performs. This is very good if you write some regex that have some errors or you want to fine-tune the loading precedence order. The first argument indicate whether this feature is enabled or not and the later notes the output file name. The output will be written to the work_path. debug_batch_error_log Default: 1, ria.log_batch.txt Used to log Batch Mode (see command line interface section) in case there were parsing errors. If not enabled, all errors will be directed to stderr (standard error stream). To make it clear, this relates to app run-time parsing errors like giving non-existing image id or any errors that can only be detected while executing the batch commands. All other command line parsing errors that prevents the app from starting are ALWAYS directed to stderr (like invalid switches and such). log_app_msg Default: 1, ria.log_app.txt Logs all user actions or reported messages/errors. This is useful in case you want to trace back your taken actions or understand why the app reported a specific set of errors. In between app sessions, this log isn't reset so it's up to the user to erase it in order to start a blank sheet. save_image_text_hex_c_array Default: 0 When saving via the hexa text option, the file will be saved as c-syntax array. This is very handy when one wishes to deploy a raw image into some program (c, c++, c# or java). Note that the file layout will preserve the format i.e. planner will lead to 3 arrays while interleave (mostly) 1 array. When disabled, the file will be saved as a hexa-editor style (good for pseudo-binary comparison). force_thread_per_core Default: 0 If you're using worker-threads to optimize performance on image 'actions', it's best to let the app/OS decide where to put each work (core-wise speaking) but if you know what you're doing or doesn't satisfied by the way the core distribution is working, you can set this parameter to 1 which will force each thread to run on a specific core (up to to the number of available logic-cores, obviously). Note that this feature is for expert users that are aware of their system behavior and this might yield to a main-thread periodic choking if applied improperly. favor_low_mem_over_speed Default: 0 In order to enable working with large-scale input or simply reducing the app memory footprint, you can "tell" the application to use less memory per-loaded image with performance-wise trade-off. Use this if you know your CPU limits and really need the memory. Memory usage is especially high when working with filtered images to speed up masking like operations. Pay attention you can dynamically enable/disable it via the Developer sub-menu so it can be fined-tuned per loaded image for maximal user control. [dialog_convert] type Default: gray Options: yuv444, yuv422, yuv420, gray, rgb packing Default: planner Options: planner, interleave bpp Default: 8b Options: 8b, 16b, 32b little_end Default: 1 Options: 0, 1 (boolean) custom_color_trans_on Default: 0 Options: 0, 1 (boolean) def_trans_c1 Set a string, parsing is done in the dialog (default: empty input). def_trans_c2 Set a string, parsing is done in the dialog (default: empty input). def_trans_c3 Set a string, parsing is done in the dialog (default: empty input). resize_on Default: 0 Options: 0, 1 (boolean) def_resize_size Set a string, parsing is done in the dialog (default: empty input). def_resize_pos_ofs Set a string, parsing is done in the dialog (default: empty input). resize_tiled_on Default: 0 Options: 0, 1 (boolean) [dialog_filter] def_filter Set a string, parsing is done in the dialog (default: empty input). def_neg Set a string, parsing is done in the dialog (default: empty input). apply_to_all Default: 0 Options: 0, 1 (boolean) apply_to_new Default: 0 Options: 0, 1 (boolean) all_3_must_pass Default: 0 Options: 0, 1 (boolean) separate_comp Default: 0 Options: 0, 1 (boolean) [dialog_ieval] def_ieval_expr Set a string, parsing is done in the dialog (default: empty input). def_out_of_range_val Set a string, parsing is done in the dialog (default: empty input). def_output_overwrite Set a string, parsing is done in the dialog (default: empty input). out_replace_image Default: 0 Options: 0, 1 (boolean) apply_on_roi Default: 0 Options: 0, 1 (boolean) output_channels Default: context Options: context, context_as_yuv, single bpp Default: by_input Options: by_input, 8b, 16b, 32b overwrite_saved_ieval Default: 0 Options: 0, 1 (boolean) compare_mode_auto_new Default: 1 Options: 0, 1 (boolean) [dialog_open] def_width Set a string, parsing is done in the dialog (default: empty input). def_height Set a string, parsing is done in the dialog (default: empty input). type Default: gray Options: yuv444, yuv422, yuv420, gray, rgb ascii Default: 0 Options: 0, 1 (boolean) packing Default: planner Options: planner, interleave bpp Default: 8b Options: 8b, 16b, 32b little_end Default: 1 Options: 0, 1 (boolean) def_offset Set a string, parsing is done in the dialog (default: empty input). [dialog_ruler] crd_screen Default: 100, 100 Set a ruler config profile for screen coordinate reference with a succeeding delta x, delta y. The delta values are of unsigned values (> 0). Non-entered values will be replaced by the default. crd_image Default: 10, 10, 0, 0 Set a ruler config profile for image coordinate reference with a succeeding delta x, delta y, offset x, offset y. Offset may be used to translate the ruler start position which is useful for alignment of image's data (like bitmaps and fonts). Offset is active for ZF 1+ as below the image pixels are being interpolated. Non-entered values will be replaced by the default. cfg_type Default: screen Set the default active ruler profile: screen or image. 'screen' means the ruler uses logical screen pixel (10 for x mean 10 screen pixels, if possible) while 'image' means the ruler will indent by image pixels. [dialog_file_modify] try_relaod_same_file_cfg Default: 1 Options: 0, 1 (boolean) This is used either try to reload the input file with its last successful config or to allow the user to enter a different image setup in case the load was unsuccessful. [Back to main index]

      Command line interface

      The command line enables a user a more automatic-labor approach which is useful when one, let's say, have a folder piled with images and a script (dos batch, python, choose your favorite scripting style...) that iterates the files, you can use the command line interface to interact with the app w/o actually doing any mouse/keyboard manual labor. You can also use it to customize a flavor like opening images in compare mode or delegate a static crop region and so on... One extra advantage is the lower memory footprint of the app as there's an option to work completely off the GUI flow, enabling to omit the overhead of display canvases. For large scale images, this might prove the dead-or-alive difference. Arguments are in affect from left to right (1, 2, 3, ...) and every opened / created image is assigned with a HK id as if it was done from the app GUI. The only exceptional argument is the file name which can be entered in a sequence but from the first encountered argument that uses a switch (-,-- hyphen) and that isn't part of the open image 'specific' switches (see -op), you must use also the -op (--open) switch to open following files. e.g. RawImageAnalyser red1.jpg blue2.png pink3.8b.raw -cmp --open white4.422.yuv This will load from local path the 3 first images and will start the app directly in compare mode (of the first 3 assuming they share dimensions and can be opened) and will also open a 4th image (use HK 4 to switch to it). If you have input that comes with spaces (like windows folder or complex expressions), remember to surround them with double quotation mark ("i have spaces") in order for them to count as single argument (same goes when using the --batch_file switch). Syntax: RawImageAnalyser [<file path>, [<-wh> <size>] [<-fmt> <string>]], ..., [-<h|op|bt|ff|cf|n|d|cmp|flt|roi|s|sst|spng|cnv|e|cls|q> <secondary options>] Note about secondary options that allow to supply image HK number. If non given, the last (most recent) opened image will be used else supply a HK from 1..N. You can also give reverse numbering so -1 is like stating the last image (e.g. -3 is the 3rd last). The -q (--quit) switch has a special underlying meaning which states that the user wishes to perform all actions but exit the app afterwards w/o ever entering its GUI state. This is effective in batch processing when one desires, for an example, to use the app as some sort of RAW image processing utility. Take note that if -q isn't used, all app dialogs are in affect which includes any multi-thread progress control.
      CommandAliasShort description
      -h --helpOutputs to the console short / long help info
      -op--openOpens an image file
      -bt--batch_fileProcess all commands from a batch file
      -ff--fmt_fileLoad a specific RAW format file
      -cf--cfg_fileLoad a specific app config file
      -n--newCreates a new image duplicate (full or ROI)
      -d--diffPerforms a difference between 2 images
      -cmp--compareEnter compare mode by supplied images
      -flt--filterPerforms a filter on an image
      -roi--reg_of_interestSets a ROI selection
      -s--saveSaves as RAW image
      -sst--save_statSaves an image statistical info + histogram (text)
      -spng--save_pngSaves an image as PNG RGB-8 file
      -cnv--convertConverts an image into a new RAW image
      -e--ievalPerforms an I-Eval on a given expression
      -cls--closeCloses up to 8 given images or all
      -q --exit --quitSilent mode, no GUI. Quits after batch processing
      Switches: [-h|--help] Outputs to stdout (console) a basic command line layout (-h) or this full user manual. The app will not enter the GUI and leave after displaying the help text. [-op|--open] <image path> [<-dims|-wh> <width x height>] ... [<-fmt|-format_str|-expr_str> <string>] Opens an image file. If the file path carries a known extension (like JPG), it will be loaded (assuming parse-able) into the app else it's assumed to be a RAW image and if a match will be found in the RAW formats file it will be loaded else a dialog of "Open Raw Image" will pop-up (assuming --quit wasn't invoked, see its switch description) and allow a user entered format. As noted previously, you can also simply open a file by entering the first arguments supplying an explicit path w/o using any hyphen (-,--) switch until first usage of any command switch. Use double-quotes if you have spaces in the file path. Extra control options: -dims, -wh <width x height> Force the RAW image's dimensions (w/o qualifying for some reg-ex match). You should supply the size in the form width x height (e.g. 640x480). -fmt, -format_str, -expr_str <string> Force the RAW image's format to be the specified string. See Format's file manual for full syntax. Note that all extra control options are optional so if omitted, the format's loader will try to match a missing datum via the reg-ex engine. If non found, the open image action will fail (full abort of the arguments parsing and application's exit). [-bt|--batch_file] <batch file path> Must be entered as first argument in order to be used. Very useful when you need to use a long batch processing and the command line isn't long enough or comfort. If this command is invoked, all extra switches are ignored and all actions are performed from the input file (which is practically, unlimited). One other advantage of this, is its ability to accept comment lines (signed with # at start of line). [-ff|--fmt_file] <format file path> Allows an explicit loading of a RAW format loader file. After loaded, it will replace any currently active format file. This can be handy in case you wish to invoke a file which is specific to some folder(s) or has some regex rules which conflict with your regular format file. [-cf|--cfg_file] <configuration file path> Allows overriding the default config file. Again, useful when one requires a different flavor of the app settings in certain scenarios like specific work path or comparison limit and so on. See Config file for further info. [-n|--new] <use_roi|image HK> Creates a new image duplicate either from a full size image or, if ROI was selected, you can choose to make a new image from the active ROI (add the use_roi command). If you don't supply arguments after the -n (or --new) then the last opened image is used i.e. with highest HK number. If you supply some HK number, then it's the one that will be used., [-d|--diff] <type1|all_bin> <type2|all_abs_delta> <type3|mask_bin> ... <type4|mask_abs_delta> <image1 HK> <image2 HK> Performs a difference between 2 images by a given diff type (default is all_bin). You can use acronym like type1 through type4 instead of supplying the long names. You must supply 2 distinct HK (else the last 2 opened will be used). A new image is created as an after effect (with HK 'old max'+1). [-cmp|--compare] <image1 HK, image2 HK, ...> Moves the app into comparison mode. This one affects only the GUI state of the app or special commands like I-Eval that are aware of the comparison party. If no image HK will be supplied, the last opened image will be taken as anchor and the app will try to layout a comparison party of all other images that share its dimensions (given they don't exceed the comparison party limit). [-flt|--filter] <image HK> <all_comp_qlfy> <sep_comp> ... [<filter_expr|fexpr> <string>] [<neg_expr|nexpr> <string>] Performs a filter on an image. Extra control options: all_comp_qlfy Pixel is valid if all 3 components are in range. sep_comp Separate to image per component. filter_expr, fexpr <string> See guidelines in Filter user dialog. neg_expr, nexpr <string> See guidelines in Filter user dialog. Note that if you wish to filter w/o affecting the original image, perform something like -n (--new) and then don't supply an image HK when filtering. Also, filtering is always performed on the currently active ROI if exists. [-roi|--reg_of_interest] <image HK> <[minX,minY..maxX,maxY]|[minX,minY..Width x Height]> Activates a ROI selection on some image given a rectangular region of interest by either giving a start and end point / image coordinate (e.g. 20,30..22,40) or a start point and size (e.g. 20,30,3x11). [-s|--save] <image HK> <text> <hex_text> <plnr|planner> <intrlv|interleave> ... <be|big_end> <ovr|overwrite_exist> [name <path>] Saves a RAW image (default is binary with original packing and x86 little-endian). Extra control options: text Save the data into a text file (pixel value), depending on the layout format (planner, interleave, etc.). hex_text Save the data into a text file by writing a hexa layout of the data as in common hex-viewers (refer to [Developer] section for other writing format options). plnr, planner Force the output packing type to be planner. intrlv, interleave Force the output packing type to be interleave. be, big_end Force the output byte-order to follow Big-Endianness rules (like Apple's native layout). ovr, overwrite_exist Force an overwriting of the input if exist w/o prompting. If in GUI mode, a dialog will pop-up if the file exists else the operation will simply fail. Use this to avoid any sort of output validation. name <path> You can force an output name even if in auto-naming state. This gives better flexibility when working with batch processing. [-sst|--save_stat] <image HK> <ovr|overwrite_exist> [name <path>] Saves an image statistical info (+histogram) into a file. The extra control options follow -s rules. [-spng|--save_png] <image HK> <ovr|overwrite_exist> [name <path>] Saves (exports) an image to a PNG (RGB 8bpp) file. The extra control options follow -sst rules. [-cnv|--convert] <image HK> [<fmt_expr|format_str|fmt> <string>] <use_def_trans> ... [col_trans <c1, ..., c2>] [resize <width expr;height expr{;ofs x;ofs y}>] ... <resize_tiled> Converts an image into a new RAW image. Extra control options: fmt_expr, format_str, fmt <string> Specifies the raw format expression (e.g. P,Y,-16 or I,RGB,8) as noted in the Formats file manual. use_def_trans Forces the color transform (if required) to use the app's system default no matter what is defined in the configuration file. col_trans Supply a custom color transformation matrix (4x3) for the conversion to use. Please note that the color transform will be in affect only if the destination format has a different color space notation, otherwise this value is ignored. If not supplied, the used transformation will be the one noted in the configuration file (else the app's system default is used). This option is mutually exclusive to 'use_def_trans'. [-e|--ieval] <image HK> [ieval_expr <string>] <oor <string>> <out_ovrd <string>> <in_roi> <out_ch_ctx_yuv|out_ch_single> <bpp8|bpp16|bpp32> Performs an I-Eval on 'ieval_expr' string. You can assume the saved I-Eval list is loaded so you can use any form of an I-Eval (as if it was entered directly via the dialog). The default activation is with out-of-range as 0, entire image is applied, creates a new image, output channel by context (RGB layout) and BPP is also by context. Note that the I-Eval engine is aware of any active comparison party but still, if you enter a 'image HK' it takes precedence (and disables any currently active comparison party on forth). Extra control options: oor <string> Sets an out-of-range value string. See I-Eval rules for the respected dialog item. out_ovrd <string> Sets an output override list string. See I-Eval rules for the respected dialog item. in_roi If there's an active ROI, will apply the I-Eval only in it. out_ch_ctx_yuv, out_ch_single Controls the output channels while 'out_ch_ctx_yuv' will set the channels by context but with YUV layout (if of 3 channels type) and 'out_ch_single' forces a single channel output. Please refer to I-Eval manual for further clarifications. bpp8, bpp16, bpp32 Suppresses the default selection by context of BPP and sets one the above values. [-cls|--close] <image1 HK, image2 HK, ...> <all> Closes up to 8 given images or all (if 'all' is specified). Useful if you finish some batch processing phase and you wish to free some HK slot or reset a new commands set. [-q|--exit|--quit] Whenever encountered in the argument's list (or the batch file commands), will signal the application to work in no-GUI mode so after the arguments are parsed and performed, the application will return to the command prompt. Also, this means all errors or app's output will be directed only to stdout / stderr. To avoid misunderstanding, if the app logs are active from the config file, they will still be used (orthogonal behavior). Several usage examples

      Note we assume all input images are open-able by the app (either a common image format or parse-able by the format's file).

      Example 1 We assume we have a batch processing listed in file ria_batch_cmd1.txt so the command argument is: RawImageAnalyser --batch_file ria_batch_cmd1.txt We wish to take a disproportional input raw image (format yuv-422) and rotate it so the width will be bigger than the height and save it to a RGB-8 file with planner BGR packing. The batch file listing is (note that comments are prefixed with #):
      
          "D:\Test Images\image_input_x496_y640_422.yuv"
          # Convert and resize the most recently opened image (HK 1)
          -cnv fmt p,b,g,r,8 resize "max(w,h); max(w,h)"
          # Use the I-Eval to mirror the image
          -e ieval_expr i[y,x]
          # Save it to some self defined name (overwrite if exists)
          -s ovr name yuv_trans.640x496.bgr.p.raw
          # Avoid any GUI (batch processing only)
          -q
          
      
      Example 2 We wish to smart difference 2 luma images by only considering a diff if values that are higher than 128 have delta of less than 5 and take this diff image and make it gray scale so each difference level will be quite noticeable and save it to a Y8 file. We assume we have a batch file ria_batch_cmd2.txt and here is its listing:
      
          luma_in1_100x90.raw luma_in2_100x90.raw
          # Use I-Eval to express the noted semantics
          --ieval ieval_expr "(i1 > 128 && i2 > 128)*(abs(i2-i1) < 5)*(1+(abs(i2-i1)))*255/5"
          -s name diff_luma_in1_2_gray.100x90.raw
          -q
          
      
      Example 3 We wish to take a known portion of our image (let's say our face) at <80,100> with size 100x100 and make a pseudo-passport out of it (4x4) while dimming the image a bit (20%) but only the actual data (luminance, not the colors). We assume the image input is RGB8 (in jpeg) and that we have ria_batch_cmd3.txt so its listing will be:
          
          # Let's assume the size is 400x300 or so...
          my_passport_img.jpg
          # Mark the face ROI
          -roi 80,100,100x100
          # Create a new image consisting only of the face
          -n use_roi
          # Convert to YUV while resizing to our final "passport" output
          --convert fmt i,yuv,8 resize w*4;h*4 resize_tiled
          # Dimmer the luminance only  
          -e ieval_expr "c1*0.8; c2; c3" out_ch_ctx_yuv
          # Export to PNG (we're getting a back to RGB conversion for free).
          # Note you can play with the default color transformations if you don't like the 
          # way it looks...
          --save_png name my_passport_img.png 
          # Leave us in GUI state so we can monitor more closely the results
         
      
      [Back to main index]

      Developer notes

      I've created the application mainly because I was looking for "pure" RAW image loading tools and found many that simply didn't focus nor answered my own needs. The most important feature I was looking at was a simple tool to see per-pixel info, w/o any sub-pixel interpolations due to zooming and one that can actually load RAW images w/o the over-exhausting need to re-enter every time the exact raw format I'm using. I also felt that the tools overall info (like statistics, diff and histogram) didn't cover what developers can benefit of. Therefor, I've sat through the nights and wrote this simple utility application. I designed it mainly for developers usage so I was cheap in GUI stuff and focused more on the features I thought are most cardinals when analyzing / comparing RAW images. For the coders among us, the software (nowadays it's called an application) was developed in C++ under native Win32 with no 3rd party libraries, non so ever (except dependency on GDI+ which isn't mandatory if you work solely with RAW files). Obviously, as this was a pet project, I did not have the time nor the resources to make a full-cycle QA on all features and think on all the app sub-flows so if you encounter some "hidden features" (a.k.a bugs :)), feel free to contact me at: CB development Also, if you have further requests of the app that you would like to see or want to share your ideas / questions, you're more than welcome... [Back to main index]