|
Raw Image Analyser Help
Raw Image Analyser Help file
Manual index:
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:
   | FI | Focus-image |
   | ZF | Zoom factor |
   | HK | Hot-key shortcut |
   | ROI | Region of interest (rectangular area of image) |
   | LE/BE | Little endian (default on x86), Big endian |
   | <Char> | Case-sensitive hot-key (HK) |
   | [Char] | Case-insensitive HK |
[Back to main index]
Summary:
Key | Short 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 |
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]
<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]
<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]
[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]
<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]
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]
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]
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
|
|
|
[Back to main index]
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...)
|
|
|
[Back to main index]
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).
- You can use I-Eval on single image or on a comparison party. When in compare mode, the
images are ordered 1 to N (left to right, visual order).
- You refer to an image with 'i'+#. 'i' alone is the same as i1. If you wish to
differentiate the channels, you can add the 'c'+# (1..3) syntax. 'c' alone refers to i1
by context (so if you have a 3 ch. image and you're on ch. 2 then it's the same as
writing explicitly i1c2).
- You can give different expression per channel via ';'. Even if the input is of 1 ch.,
you can create an output of 3 ch. by writing expression like {c;c;c}. If you write an
expression like { (i2+i1)/2; abs(i2-i1); i2^2/i1^2 } then the I-Eval engine will apply
the proper value per channel so the above is equivalent to the expanded expression:
{ (i2c1+i1c1)/2; abs(i2c2-i1c2); i2c3^2/i1c3^2 }
- You can mix 1 ch. and 3 ch. images in the same expression as the engine will match the
proper channel semantics. However, writing token like i2c2 for a 1 ch. image will have
a don't care affect (as if it was i2c1).
- To allow strong expressions, 'x' and 'y' are reserved variables that state the currently
iterated coordinate. This is useful to distinguish the spatial location in a run like
masking only odd lines with { (y % 2)*i }. Note that the coordinate is 0-based so we
start at <0,0> and end at <w-1,h-1>.
- You can also use 'w' and 'h' to state width and height which is quite useful for say,
mirroring an image horizontally {c[w-1-x,y]} or vertically {c[x,h-1-y]}.
- When ROI in an image is active, you can use in the expression the following variables:
x1,y1,x2,y2,cw,ch which means respectively: left, top, right, bottom, crop area width
and crop area height.
- You can access at any iteration any required pixel by using the indexing syntax of
i[X,Y] (or c[X,Y], i2c3[X,Y], etc.). This is super important if you wish to apply any
kind of transform or kernel based filter. A simple 3x3 dilate operation can be:
{ ((c[x-1,y-1]+c[x,y-1]+c[x+1,y-1]+c[x-1,y]+c+c[x+1,y]+c[x-1,y+1]+c[x,y+1]+
c[x+1,y+1]) > 0) * 255 }
- The indexing feature supports any dereferencing level so if you have 2 images that one
is used as a distance seed map, you can write expression like {i[i2[x,y],i2[x*2,y*2]]}.
See the dialog options section for 'out-of-range values'.
- If in some dereference context, X or Y are not positive integer (0 included) then
a truncated value will be used.
- If you wish to apply several operations in a pipe fashion, you can write several I-Eval
expressions with this basic syntax {...} {...}. Good example is Opening (erode+dilate)
that can be achieved by (for 3x3 kernel):
{ ((c[x-1,y-1]+c[x,y-1]+c[x+1,y-1]+c[x-1,y]+c+c[x+1,y]+c[x-1,y+1]+c[x,y+1]
+c[x+1,y+1]) > 0) * 255 } { ((c[x-1,y-1]+c[x,y-1]+c[x+1,y-1]+c[x-1,y]+c+c[x+1,y]
+c[x-1,y+1]+c[x,y+1]+c[x+1,y+1]) == 255*9) * 255 }
- As expressions can be complex, you can save them for later usage and apply them via
the 'List of saved I-Eval expressions' list. Each L-double-click will append the
selected I-Eval to the currently edited expression. Use R-click to expand the I-Eval
expression itself (good for temporary editing).
- You can reference a saved expression via $saved name$ (must be a complete I-Eval
expression) so the above example, assuming you saved Erode3x3 and Dilate3x3 can be
entered as {$Erode3x3$} {$Dilate3x3$}. You can further optimize your work by declaring
a new I-Eval named Opening_3x3 as {$Erode3x3$} {$Dilate3x3$} and place $Opening_3x3$
in the editor.
- An I-Eval name must start with a [a-z,A-Z,_] and can be followed by alpha-numeric and
any of ' :;,-+*/=~_&|#!?(){}[]'.
- All expressions are case sensitive.
- 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)
|
|
|
- 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 operands | Output yields 0/1 |
|| | Or |
&& | And |
! | Not |
Comparison operands | Output yields 0/1 |
< | Lower than |
> | Greater than |
<= | Lower than or equal |
>= | Greater than or equal |
== | Equal |
!= | Not equal |
Bitwise operands | Integer 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 |
Trigonometric | Input 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]
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]
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 description | Default |
gui | Affects GUI related properties like
colors and view modes |
ruler_color | Set a ruler color list | red, white |
ruler_font | Set a ruler font | Arial, 16, 12 |
ruler_type_matrix | Set the ruler mode to be indent/matrix | 0 |
tab_font | Set the tab font | Arial, 16, 12 |
tab_color_fg_bg_hl | Set the tab color | white, <150;30;20>, <200;70;0> |
pixel_display_base | Pixel value base dec/hex | dec |
value_comma_decorate | Decorate decimal values comma | 0 |
histogram_max_height | Max histogram height (in pixels) | 80 |
histogram_transparent | Histogram transparent background | 0 |
histogram_transparent_fg_color | Histogram transparent FG color | white, black |
histogram_transparent_shadow | Histogram high contrast shadow | 0 |
def_zoom | Initial app zoom-factor | 0 |
ruler_mode | Initial app ruler mode | 0 |
grid_mode | Initial app grid mode | 0 |
pixel_value_mode | Initial app pixel value mode | 0 |
image | Affects image manipulation or
semantic of action taken on images |
trans_yuv_to_rgb | YUV to RGB color transform | ITU-R BT.2020 (JPEG) |
trans_rgb_to_yuv | RGB to YUV color transform | ITU-R BT.2020 (JPEG) |
diff_type | Initial app diff type | all_bin |
system | Affects app behavior and
path related options |
work_path | App log files path | Execution path |
format_file_path | Path of RAW formats file | RawImageAnalyser.fmt |
ieval_file_path | Path of saved I-Eval list | ria.ieval.txt |
ieval_load_saved_startup_only | Load I-Eval list only on init | 0 |
reload_dialogs_edit_history | Reload previous sessions edit
boxes history | 0 |
max_comparison_party | Max allowed images to compare | 6 |
ignore_file_extern_modify | Ignore file modifications | 0 |
auto_file_naming | Auto file naming when saving | 1 |
app_close_prompt | Prompt the user when quitting | new_created_image |
max_process_threads | Max processing worker threads | 0 (unlimited) |
auto_check_updates | Auto check for app new versions | 1 |
developer | Designed for debugging and
more advanced verbose info |
debug_load_format_log | Log load RAW formats process | 0 |
debug_batch_error_log | Log batch run-time errors | 0 |
log_app_msg | Log app actions / errors | 0 |
save_image_text_hex_c_array | Save hexa-text as C array | 0 |
force_thread_per_core | Force thread per-core | 0 |
favor_low_mem_over_speed | Reduce memory usage in
trade-off of performance | 0 |
dialog_convert | Affects dialog 'Convert raw'
initial controls state |
type | yuv444, yuv422, yuv420, gray, rgb | gray |
packing | planner, interleave | planner |
bpp | 8b, 16b, 32b | 8b |
little_end | Boolean | 1 |
custom_color_trans_on | Boolean | 0 |
def_trans_c1 | String | |
def_trans_c2 | String | |
def_trans_c3 | String | |
resize_on | Boolean | 0 |
def_resize_size | String | |
def_resize_pos_ofs | String | |
resize_tiled_on | Boolean | 0 |
dialog_filter | Affects dialog 'Filter colors'
initial controls state |
def_filter | String | |
def_neg | String | |
apply_to_all | Boolean | 0 |
apply_to_new | Boolean | 0 |
all_3_must_pass | Boolean | 0 |
separate_comp | Boolean | 0 |
dialog_ieval | Affects dialog 'Image evaluator'
initial controls state |
def_ieval_expr | String | |
def_out_of_range_val | String | |
def_output_overwrite | String | |
out_replace_image | Boolean | 0 |
apply_on_roi | Boolean | 0 |
output_channels | context, context_as_yuv, single | context |
bpp | by_input, 8b, 16b, 32b | by_input |
overwrite_saved_ieval | Boolean | 0 |
compare_mode_auto_new | Boolean | 1 |
dialog_open | Affects dialog 'Open raw'
initial controls state |
def_width | String | |
def_height | String | |
type | yuv444, yuv422, yuv420, gray, rgb | gray |
ascii | Boolean | 0 |
packing | planner, interleave | planner |
bpp | 8b, 16b, 32b | 8b |
little_end | Boolean | 1 |
def_offset | String | |
dialog_ruler | Affects dialog 'Ruler config'
initial controls state |
crd_screen | Screen coordinate initial data | 100, 100 |
crd_image | Image coordinate initial data | 10, 10, 0, 0 |
cfg_type | screen, image | screen |
dialog_file_modify | Affects dialog 'File modify'
initial controls state |
try_relaod_same_file_cfg | Boolean | 1 |
[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]
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.
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]
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]
© CB-Development
|