Dynamical correlation between two graphics possible ?

Share icon

Hello everybody :)

I'm an Igor newbie and I want to duplicate a function of another program (developed in C) in my data analyzing in Igor.

Initialy I have a 256x256 .tiff image.

With simples equations I extract in Igor from this image 2 maps :
1 map of Itensity and
1 map of Brightness.
Each of them are 256x256 waves (see attached images) and are displayed in the main window.

I vectorized the maps information (instead of 2D[256][256] waves I create 1D[65536] waves)
I plot the Brightness vs Intensity for the vectorized maps and I displayed it in the same window.



I want to know if there is a possibility to obtain dynamicaly a visual correlation between a region of the "VerSus graph" and the corresponding pixels in the images of the maps.


The square representation is the ideal display I would want to get but it's not restrictive.



As I don't really know how to ask to Igor to re-lauch a "function" (/proc/macro) each time the mouse is acting in the graphic, the only thing I managed to program is a non-dynamical defininition of a region (with 4 setvariable) and with a "button" to lauch a function.
The function just checks the value of the brightness and of the intensity and creates a mask to change the pixels in red.

It's very time consuming.

Does anyone know if it's possible to ask to Igor to maintain the execution of the program in a "waiting" state in order to lauch a loop when interacting with a graphic ?


Thank you very much

The attached files are :

01 - The Intensity map
02 - The Brightness map
03 - The Brightness versus Intensity graphic extract from the 2 vectorised maps
04 - The display of the window with the 3 elements.
05 - Example number one of the correleation between a defined square of pixels of the Versus Graph and the corresponding pixels in the 2 maps
06 - Same example but with the square moved to the right.
07 - Igor project with the differents waves. 01 - Intensity map.jpg (47.93 KB) 02 - Brightness map.jpg (68.51 KB) 03 - Versus Graphic.jpg (16.99 KB) 04 - Raw Display.jpg (123.78 KB) 05 - Display with the square.jpg (120.87 KB) 06 - Display with the square moved.jpg (120.98 KB) 07 - Simplified experiment.pxp (1.05 MB)
I have code that pretty much does what you want but it is integrated in a larger package and I cannot promise to extract the important bits and pieces in a short amount of time. And it's different in the way that I work with maps containing integers, which has consequences for my approach. That is:

- Redimension both maps from 2D into 1D
- Create a bivariate Histogram (see e.g. http://www.igorexchange.com/node/4651). Here my approach is that the bin size for the histogram is always 1 count (of intensity)
- Plot histogram as NewImage
- Then I use a region of interest (ROI) tool (under image analysis) to select an area on the histogram (see picture), which means creating a mask with 1 for "within the ROI" and 0 for outside
- After multiplication of the mask with the histogram I am left with pairs, say X and Y, of intensities of two elements
- Now the task is to find the pixels in the initial 2D images where X AND Y counts occur. This is simplified by using a Cantor pairing function to generate one unique integer out of two: http://en.wikipedia.org/wiki/Pairing_function
- now the XY pairs from the histogram and the two 2D maps are "cantored"
- then I need to find the correct Cantor values. For this I got input here: http://www.igorexchange.com/node/5447 , although my final version differs from what I wrote back there

All this is implemented in a graphical user interface (see image). The visualisation of the pixels is executed when clicking the "Get Pixels" button. Initially I wanted this automatically to run once the polygon from the ROI action closes, but I didn't find a way to do that.

Hope this gives you an idea but maybe there are better ways.
IntensityMap.png (81.2 KB)

February 4, 2014 at 05:26 am - Permalink
Hello,

Thank you for your answer.

If I understand well, you are suggesting to transform my "versus graphic" into an image in order to "Cantor pairing" the pixels.

My little problem with this option is that the rest of my program is interacting with the data inside the "versus graphic" and I want to keep it dynamically updated when changing parameters (Threshold of intensity and brightness for example).

* The correlation between the pixels of the "maps images" and the pixels of my "versus graphic" is obvious in my case :
each pixel of the map has a [i][j] coordinate (256x256).
In the "Versus graphic" made from the vectorized maps each point has an index between 0 and 65536.
I can extract the coordinate in [i][j] of each point of my "versus graphic" doing this : [i] = floor (index/256) and [j] = mod(index, 256)


* If I manage to draw a rectangle in this graphic, when selecting several point with this rectangle, I will obtain their coordinate in the maps directly with their index.

But I don't know how to draw a rectangle in my "versus graphic" (and I don't know if it's possible) without changing it into image (to keep the live update I need). Moreover, I don't know how to identify the points selected in the graphic (like the masqueetomask tool which creates a mask with 0 and 1).



I'll keep going to find a solution and I'll try to adapt yours but, even if your work seems very close to mine, I'm not sure it will fit with my needs.

Thank you again :)

February 5, 2014 at 01:34 am - Permalink
Djebulon wrote:
If I understand well, you are suggesting to transform my "versus graphic" into an image in order to "Cantor pairing" the pixels.
My little problem with this option is that the rest of my program is interacting with the data inside the "versus graphic" and I want to keep it dynamically updated when changing parameters (Threshold of intensity and brightness for example).



Looking closer at your data it is probably not possible to easily adapt my approach to your data. The pairing works for integers, which in my case typically are between 0 and a few hundred (max) for both input images. The main advantage is to speed up the look-up process to find the desired pixel coordinates. The above approach is virtually instant for images up to 512*384 pixels (larger not tested). For me it is important to have the density plots because I'm looking for distinct populations with high pixel abundances of count pairs.


Djebulon wrote:
But I don't know how to draw a rectangle in my "versus graphic" (and I don't know if it's possible) without changing it into image (to keep the live update I need). Moreover, I don't know how to identify the points selected in the graphic (like the masqueetomask tool which creates a mask with 0 and 1).


This you can do using 
FindPointsInPoly
and 
GraphWaveDraw
, which can be used to achieve pretty much the same as the ROI mask does on the 2D histogram.

February 5, 2014 at 02:04 am - Permalink
Thank you very much for these 2 functions.

I will try to see if I can adapt them to my problem but they seem promissing.

February 5, 2014 at 08:21 am - Permalink
Well, here is the piece of code that finds the pixels. This assumes that the histogram and the ROI mask already exist. Maybe you can modify it to fit your needs.


function/WAVE  PixFromHistogram(xw, yw, M_Hist, M_ROIMask)   
	wave xw, yw, M_Hist, M_ROIMask

	variable rows = DimSize(xw, 0)
	variable cols = DimSize(xw, 1)	
	
	// Set pixels outside ROI to zero
	MatrixOP/FREE/O M_PixHistROI = M_Hist * M_ROIMask
	
	// convert ROI and histogram information into into 1D waves, keep index information on intensity	
        variable rowsHist = DimSize(M_PixHistROI , 0)
	variable colsHist = DimSize(M_PixHistROI , 1)
	Make/FREE/O/N=(rowsHist * colsHist) nPix, countsX, countsY
	Multithread nPix = M_PixHistROI[p]
	Multithread countsY= floor(p / rowsHist )
	Multithread countsX = mod(p, rowsHist)	
	sort nPix, nPix, countsX, CountsY
	
	// condese waves to rows that contain pixels
	Multithread nPix = nPix == 0 ? NaN : nPix
	variable MinCount = WaveMin(nPix)
	Findlevel/P/Q nPix, MinCount
	DeletePoints 0, (V_LevelX), nPix, countsX, countsY 	
	
	variable nXYpairs = numPnts(nPix)
	
	// make waves to keep results vom Cantor function
	Make/FREE/O/I/U/N=(nXYPairs) ROISolutions 
	Make/FREE/O/I/U/N=(rows * cols)  MapSolutions
	
	// make unique integers using cantor pairing function
	MultiThread ROISolutions = Cantor(countsX[p], countsY[p])
	MultiThread MapSolutions = Cantor(xw[p], yw[p])
	
	// Make result wave unsigned 8 bit to make it compatible with ImageMorphology
	Make/O/B/U/N=(rows * cols) M_PixFromDensityPlot = 0  

	// make a point order wave and sort cantor integers 
	Make/FREE/O/N=(numPnts(MapSolutions)) PntOrder = p
	Sort MapSolutions MapSolutions, PntOrder
	Sort ROISolutions ROISolutions


	// clip everything outside the WaveMin(ROIsolutions) to WaveMax(ROIsolutions) range in the map wave
	FindLevel/Q/P MapSolutions,  WaveMin(ROISolutions)
	DeletePoints 0, V_LevelX, MapSolutions, PntOrder	
	FindLevel/Q/P MapSolutions, WaveMax(ROISolutions)+1
	DeletePoints V_LevelX, inf, MapSolutions, PntOrder

	variable np = numpnts(ROISolutions)
	variable length = numpnts(MapSolutions)
	Make/FREE/O/N=(length) tmp=NaN
	

	//Find values from ROI in 1D Cantor wave MapSolutions
	// BinarySearchInterp returns the point number if value is present in a wave or a fractional, interpolated pointnumber if value is not present
	// use Mod(value, 1) to determine whether return value has a remainer when devided by 1   
	Multithread tmp = mod(binarySearchInterp(ROISolutions, MapSolutions[p]), 1) == 0 ? 1 : NaN
	
	// eliminate points in PntOrder which are NaN 
	Multithread PntOrder *= tmp
	WaveTransform zapNaNs PntOrder

	// Fill output wave in 1D with 1 for pixels in ROI
	variable i
	for (i=0; i<numPnts(PntOrder); i+= 1)		
		M_PixFromDensityPlot[PntOrder[i]] = 1 
	endfor
	
	// make 2D image from 1D wave	
	Redimension /N=(rows,cols) M_PixFromDensityPlot
		
	Return M_PixFromDensityPlot
end

ThreadSafe function Cantor(aa, bb)
	variable aa, bb
	
	variable sumTerm  = aa + bb
	return  1/2 * (sumTerm) * (sumTerm + 1) + bb
end


The attached experiment shows an example. Execute 

PixFromHistogram(Al, Si, M_Hist, M_ROIMask)


to get a mask of the pixels of interest.

You can play with different ROI's on the histogram using "Analysis -> Packages -> Image Processing" then "Image -> ROI". Make sure you uncheck "Zero ROI pixels" in the panel.
ShowPixels.pxp (203.14 KB)

February 6, 2014 at 03:56 am - Permalink
Thank you very much for you code !!!

Okay it seems that I have a lot of work to adapt it to my issue :S

But with 
 FindPointsInPoly
and 
GraphWaveDraw
and with your code, I will find a way to do it.


I'll let you know when it will be done ...


Thank you again !

February 6, 2014 at 06:13 am - Permalink
Djebulon wrote: ...But I don't know how to draw a rectangle in my "versus graphic" (and I don't know if it's possible) without changing it into image (to keep the live update I need). Moreover, I don't know how to identify the points selected in the graphic (like the masqueetomask tool which creates a mask with 0 and 1).


Have you looked into using the Marquee for this?

February 6, 2014 at 06:30 am - Permalink
Yes and what I wanted to do initially was to draw a rectangle and to be able to drag it with the mouse. (it's possible with the marquee but the rectangle hasn't any interaction with the data stored in waves)
With the marquee option, you can have a rectangle but you just identify the coordinates once. (right clicking and doing marquee2mask)

When it's done, I didn't find a way to shift the rectangle and to act dynamically on the image displaying the identified pixels (when dragging the rectangle)

February 10, 2014 at 07:03 am - Permalink
Djebulon wrote: I didn't find a way to shift the rectangle and to act dynamically on the image displaying the identified pixels (when dragging the rectangle)


I just tried this on my code:


Function HistogramHook(s)
	STRUCT WMWinHookStruct &s
	
	switch(s.eventCode)
		
		case 8: 				
			
		print "modified"
                // run code to save ROI using ImageGenerateROIMask and to extract pixels
		
		break
						
	endswitch
	
	return 0
End


This works kind of dynamically after dragging the ROI and release of the mouse button, not while the ROI is moving. But there are side effects because this action may be triggered by other events than moving the ROI.

February 11, 2014 at 02:30 am - Permalink
Thank you for all your answer !

I managed to get almost what I wanted using a little trick and only buttons.
I don't drag the rectangle but I shift it.

Thank you Chrlie for these 2 functions : 
 FindPointsInPoly
and 
 GraphWaveDraw 




-------------------------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------------------------
// Allows the drawing of a polygone inside the Versus Graphic
Function SquareDRAW(Ctrlname) : ButtonControl
	String Ctrlname

	Variable k
	String/G VSGraph
	Variable/G BooleanDraw
	Wave xWavePoly, yWavePoly, W_inPoly, PixelsToEnlight
	
	k=1	
	if (BooleanDraw==1)				// If the SquareDraw button has already been activated 
		DoAlert/T="Warning" 1, "The Polygone has already be drawn ! \r\n Do you want to erase it and draw another one ?"
		if (V_flag==2)
			k=0
		endif
	endif
	
	Switch (k)
		case 1:						// Draw a new polygone
			
			W_inPoly = 0
			PixelsToEnlight = 0
	
			SetDrawLayer/W=Prog_Window#BvsI/K UserBack
			SetDrawLayer/W=Prog_Window#BvsI UserBack
			GraphWaveDraw/W=Prog_Window#BvsI/O yWavePoly, xWavePoly
			
			BooleanDraw = 1
			
			break
		
		case 0:						// Don't draw a new polygone
			
			break
	Endswitch

End	

-------------------------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------------------------
// Identifies the pixels inside polygone of the Versus Graphic	
Function SquareDONE(Ctrlname) : ButtonControl
	String Ctrlname

	Variable i, k
	Variable/G Rows, Columns, BooleanDraw
	Wave xWavePoly, yWavePoly, VInt, VBright, W_inPoly, PixelsToEnlight
	
	k=1
	if (BooleanDraw==0)				// If the SquareDraw button has NOT already been activated 
		DoAlert/T="Warning" 0, "The Polygone has to be drawn first !"
		k=0
	endif
	
	Switch (k)
		case 1:						// Indentifies the pixels inside the drawn polygone
			
			FindPointsInPoly VInt, VBright, xWavePoly, yWavePoly
			GraphNormal/W=Prog_Window#BvsI
	
			For (i=0;(i<(Rows*Columns));i+=1)
		
				if (W_inPoly[i]==1)
					PixelsToEnlight[floor(i/columns)][mod(i, columns)] = 65536
				endif
			Endfor
			BooleanDraw = 0
			
			break
		
		case 0:						// No polygone drawn => no identification
			
			break
	Endswitch
	
End

-------------------------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------------------------
// Displays the selected pixels inside the Intensity map
Function CorrelationON(Ctrlname) : ButtonControl
	String Ctrlname

	Variable k
	Variable/G BooleanCorrel, BooleanDraw
	Wave Intensity, PixelsToEnlight
	
	k=1
	if (BooleanDraw==1)
		SquareDONE(Ctrlname)
	endif
	
	if (BooleanCorrel==1)				// If the CorrelON button has already been activated 
		DoAlert/T="Warning" 0, "Selected pixels have already been displayed !"
		k=0
	endif
	
	Switch (k)
		case 1:						// Creates the matrix of pixels to display and superimposes it on the map
			
			ModifyImage/W=Prog_Window#Map1 Intensity ctab= {0.001,*,Grays,1};DelayUpdate
			ModifyImage/W=Prog_Window#Map1 Intensity minRGB=(52224,52224,52224),maxRGB=0
			AppendImage/W=Prog_Window#Map1 PixelsToEnlight; DelayUpdate
			ModifyImage/W=Prog_Window#Map1 PixelsToEnlight ctab= {0.01,*,CyanMagenta,0};DelayUpdate
			ModifyImage/W=Prog_Window#Map1 PixelsToEnlight minRGB=NaN,maxRGB=0
			
			BooleanCorrel = 1
			
			break
		
		case 0:						// Matrix already displayed
			
			break
	Endswitch
	
End	

-------------------------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------------------------
// Restore the intensity map.
Function CorrelationOFF(Ctrlname) : ButtonControl
	String Ctrlname

	Variable k
	Variable/G BooleanDraw, BooleanCorrel
	Wave Intensity, PixelsToEnlight
	
	k=1
	if (BooleanDraw==1)
		SquareDONE(Ctrlname)
	endif
	
	if (BooleanCorrel==0)				// If the CorrelOFF button has already been activated 
		DoAlert/T="Warning" 0, "Intensity map is already in normal mode"
		k=0
	endif
	
	Switch (k)
		case 1:						// Removes the selected pixels from the intensity map
			
			RemoveImage/W=Prog_Window#Map1 PixelsToEnlight
			ModifyImage/W=Prog_Window#Map1 Intensity  ctab= {*,*,SpectrumBlack,0};DelayUpdate
			ModifyImage/W=Prog_Window#Map1 Intensity minRGB=0,maxRGB=0
	
			BooleanCorrel = 0
			
			break
		
		case 0:						// Selected pixels already removed
			
			break
	Endswitch
	
End	
-------------------------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------------------------









-------------------------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------------------------
Function Left(Ctrlname) : ButtonControl
	String Ctrlname

	Variable i, k
	Variable/G RectRadioVal
	Variable/G BooleanDraw, BooleanCorrel, Xincrement, Rows, Columns
	Wave xWavePoly, yWavePoly, W_inPoly, PixelsToEnlight, VInt, VBright
	
	k=1
	if (BooleanDraw==1)
		DoAlert/T="Warning" 0, "Pixels inside the Polygone have to be identified first with the SquarDONE button"
		k=0
	endif
	if (BooleanCorrel==0)
		DoAlert/T="Warning" 0, "The correlation between Versus graphic and map should be enable first"
		k=0
	endif
	
	Switch (k)
		case 1:						// translate the polygone to the left
	
			If (RectRadioVal ==1)								// Rectangle shift selected
			
				For (i=0;(i<dimsize(xWavePoly, 0));i+=1)
					xWavePoly[i] = xWavePoly[i] - Xincrement
				Endfor
			Endif
			
			If (RectRadioVal==2)								// Rectangle size increasement selected
				xWavePoly[0] = xWavePoly[0]-Xincrement
				xWavePoly[3] = xWavePoly[3]-Xincrement
				xWavePoly[4] = xWavePoly[4]-Xincrement
			Endif
				
			RemoveImage/W=Prog_Window#Map1 PixelsToEnlight
			PixelsToEnlight = 0
			W_inPoly = 0
			FindPointsInPoly VInt, VBright, xWavePoly, yWavePoly
			
			For (i=0;(i<(Rows*Columns));i+=1)
				if (W_inPoly[i]==1)
					PixelsToEnlight[floor(i/columns)][mod(i, columns)] = 65536
				endif
			Endfor
		
			AppendImage/W=Prog_Window#Map1 PixelsToEnlight; DelayUpdate
			ModifyImage/W=Prog_Window#Map1 PixelsToEnlight ctab= {0.01,*,CyanMagenta,0};DelayUpdate
			ModifyImage/W=Prog_Window#Map1 PixelsToEnlight minRGB=NaN,maxRGB=0
		
			break
	
		case 0:						// No translation due to inactivation of Square or Correlation
		
			break
	Endswitch
	
		
End	
-------------------------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------------------------------------------


And four buttons and associated functions are created : Left, Right, Up and Down with 2 setvariable : x-increment and y-increment.

If you think you will be intersted in this non-complete method, I can simplify my procedure file and post a saved experiment here with an exemple.

February 14, 2014 at 06:32 am - Permalink