[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

RE: Avoiding looping when applying a 'find' function to an array - David

From: Harbinson, Jeremy
Subject: RE: Avoiding looping when applying a 'find' function to an array - David Bateman reply
Date: Wed, 13 Apr 2005 18:03:41 +0200

Thanks for the speedy response.
There is an extra problem which I left out in the earlier posting in
order to try and keep it simpler, but which may be relevant to the
look_up_table function. This seems to expect a two-column table. What I
am writing at the moment is really a prototype for something where I
will have to find a value in four column look-up table - three columns
of indices and one column of return values. 

Ultimately I need to convert a false colour image back to the original
data array.  The false colour image is a 24 bit tiff file which I can
convert to three arrays corresponding to the R, G and B channels using
ImageJ. I have been able to create a table of R, G and B values matched
with the corresponding original data values - a four column table. In
the end I need to locate a row (and thus an output value) in the look-up
table based on a comparison of elements from three input arrays (and
many rows in the look-up table will have many entries in the 'red'
column = 255, or entries in the green column = 0, for example):

I was planning to use a find function such as the following (which seems
to work):

Location_of_output_value= find(red_channel_array(I,J) ==
look_up_table(:,1) & green_channel_array(I,J) == look_up_table(:,2) &
blue_channel_array(I,J) == look_up_table(:,3)) 

Where the red values in the look-table are found in (:,1), green in
(:,2) and blue in (:,3).  

Sorry that my first posting was misleading,

All the best,

-----Original Message-----
From: David Bateman [mailto:address@hidden 
Sent: woensdag 13 april 2005 17:20
To: Harbinson, Jeremy
Cc: address@hidden
Subject: Re: Avoiding looping when applying a 'find' function to an


Have you seen the "lookup" function in octave-forge? I believe it does
exactly what you want. Follow your syntax below, it would be used
something like

output_array = look_up_table (lookup (look_up_table, input_array));


Harbinson, Jeremy wrote:

>I have a problem which can be easily solved by looping, but which I 
>would like to try to solve by avoiding loops.
>I need to transform one array to another equally sized array using a 
>look-up table.
>If the input array is A, then I take the value of each element of array

>A one by one, and using the 'find' function, I find the appropriate 
>value for the matching element for the output array via the look-up 
>table. Looping over every element in array A works just fine - for each

>element in A I can obtain an output value for the output array. However

>I can not think of way of doing this same task without looping - that 
>is, applying the 'find' function to each element and producing an 
>output array without looping.
>If I input:
>Location_of_value_for_output_array = find(input_array(1,1) ==
>then I get the correct location in the look-up table for the value 
>required in the output array, and then I increment the index of 
>input_array etc - this is slow because the array is 512 times 512 array

>(a graphics file) and the look-up table is 574 rows long.
>However if I try the following:
>Location_of_value_for_output_array = find(input_array(:,:) ==
>Location_of_value_for_output_array = find(input_array == look_up_table)
>then I have no success.
>Any help would be much appreciated,
>Jeremy Harbinson      
>Octave is freely available under the terms of the GNU GPL.
>Octave's home on the web: How to fund new 
>Subscription information:

David Bateman                                address@hidden
Motorola Labs - Paris                        +33 1 69 35 48 04 (Ph) 
Parc Les Algorithmes, Commune de St Aubin    +33 1 69 35 77 01 (Fax) 
91193 Gif-Sur-Yvette FRANCE

The information contained in this communication has been classified as: 

[x] General Business Information
[ ] Motorola Internal Use Only
[ ] Motorola Confidential Proprietary

Octave is freely available under the terms of the GNU GPL.

Octave's home on the web:
How to fund new projects:
Subscription information:

reply via email to

[Prev in Thread] Current Thread [Next in Thread]