From help-octave-request at bevo dot che dot wisc dot edu Fri Dec 20 16:10:10 2002
Subject: octave and image processing
From: "John W. Eaton" <jwe at bevo dot che dot wisc dot edu>
To: Al Niessner <Al dot Niessner at jpl dot nasa dot gov>
Cc: help-octave at bevo dot che dot wisc dot edu
Date: Fri, 20 Dec 2002 16:09:45 -0600

On 19-Dec-2002, Al Niessner <Al dot Niessner at jpl dot nasa dot gov> wrote:

| How can/should octave be changed to allow for processing very large
| images? 

What do you want to be able to do with the image object?

If you are looking for arbitrary numerical operations on images, then
I don't see how you will be able to work on them without a lot of
memory since you will probably want to use double precision
arithmetic.  Even if single precision is good enough for image
manipulation, I'm not sure that you will be able to get that in
Octave, since I think it would be difficult to support both double and
float arithmetic in Octave.

If you don't need arbitrary numerical operations, then perhaps it
would help to have int/short/char size matrix objects that can be used
to store data?  I'm not sure what operations would be useful for these
objects.  Would we want integer arithmetic rules, or conversion to
double?

I do think it would be useful for Octave to be able to do more things
with images and for those operations to use less memory, but I'm
curious to know why you don't simply use something that is already
designed for image manipulation (the Gimp?).

If the current limit on matrix size is not the problem, but you would
like to have reference arguments for functions so modifying a value
that is passed to a function does not force a copy and also modifies
the object in the caller's workspace, then I think that might be a
possibility, but it will require some significant changes to Octave.
What should the syntax be?  I assume we would want to mark certain
function arguments as "pass-by-reference" when the function is
defined.  What should happen for something like

  a = some_value ();
  b = a;
  do_something (a)

if the argument to do_something is a reference?  Should both a and b
change, should a copy be forced at the point of the call (so only a is
modified), or should the call fail?  What about nested calls when the 
inner function takes a reference argument but the outer one does not?
I would guess that we would have to force a copy at the nested call or
fail, since variable passed in the outer call should not change.

Finally, handling large matrices (> 2GB) will require some changes to
Octave, and then you will also need to be using a 64-bit system.  I
would like to make changes like this, but I don't know when it will
happen.

jwe



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

Octave's home on the web:  http://www.octave.org
How to fund new projects:  http://www.octave.org/funding.html
Subscription information:  http://www.octave.org/archive.html
-------------------------------------------------------------