interpolation for a color image?
AE lover
I am considering the case of bilinear interpolation for a color image
(say RGB image), to apply a bilinear interpolation, will we apply the
formular of bilinear interpolation, which we use for a gray image, for
each channel R, G, and B, separately?
If so, why don't we take into account the interaction between three
channels?
Thanks
Thomas Richter
Interesting idea, and a longer answer.
It depends on what you think your image channels will be, and how to make
use of their correlation. A typical way to do that is to first transform
them to a different color space, for example YUV. The transformation between
YUV (and related other spaces) is linear, and the bilinear interpolation
filter is linear as well, but in a different dimension. This means that
it actually makes *no* difference at all whether you first transform to
YUV, run there a bilinear filter, then transform back, or run the bilinear
filter on RGB itself. The result will be the same. But *only* because
bilinear filtering is linear, and YUV to RGB is a linear transformation.
If you pick a nonlinear color space (say, CIElab) and/or a nonlinear
filter (say, bicubic), things will be not so easy and the results will
be different. Probably not much different, since the purpose of interpolation
filters is to create pixels that are not very different from the surrounding.
Anyhow, if quality is of your concern, I would suggest to use a higher
interpolation filter, bicubic is typically fine.
So long,
Thomas
Martin Leese
What interaction? Obviously there is
interaction, but it varies with the content
of the image. Therefore, there cannot be a
one-size-fits-all solution.
--
Regards,
Martin Leese
E-mail: ple...@see.Web.for.e-mail.INVALID
Web: http://members.tripod.com/martin_leese/
Simon Johan
"AE lover" <aelo...@gmail.com> wrote in message
news:2a03e221-19de-4e85...@k37g2000hsf.googlegroups.com...
Quaternion convolution?
ImageAnalyst
---------------------------------
I think I've seen where you get color artifacts if you do this in RGB
space, especially at edges (where the color changes abruptly). This
is reduced if you interpolate in a different color space such as HSI
(which takes into account interactions, like you say, because the HSI
bands are weighted sums or formulas of RGB.)
http://www.easyrgb.com/index.php?X=MATH
Regards,
ImageAnalyst
aruzinsky
You cannot properly interpolate on the H channel. Suppose you have a
red ( H = 0 degrees ) object against a blue ( H = 240 ) background.
Bilinearly interpolating to the middle you get H = 120 so you will get
a lime green border around the object. Not to mention 0 and 359 are
both red so you can get every other color interpolating within a
completely red region.
I have seen odd instances where changing the RGB gamma to 2.2 (or is
it the reciprocal) produces better results, but in most cases it is
better leave gamma alone.
Thomas Richter already said everything important.
ImageAnalyst
>
> - Show quoted text -
----------------------------------------------------------------------------
But why can't you interpolate in a more intelligent way? You go
around the clock in the direction that is closest, so the average of 0
and 359 would be 359.5 (still a red), and the average of 0 and 240
would be 300 (rather than 120) which is a purple which seems like it
could be a reasonable and acceptable interpolation of red and blue.
Marco Al
> If so, why don't we take into account the interaction between three
> channels?
What interaction did you have in mind?
R1 is a convolution over the spectrum of color 1, R2 is the same
convolution over the spectrum of color 2 ... if I make a weighted blend
of color spectrum 1 and 2 and apply the convolutions, hey what do you
know I get the same result as blending R1 and R2 with the same weights.
I see no interaction with the other colors. Of course this is assuming
linear RGB ... it's non trivial to get close to linear RGB, but black
level correction and gamma expansion will probably get you close enough.
Especially since you are using bilinear interpolation :)
Marco
ImageAnalyst
-----------------------------------------
AE Lover (Is that for "AutoExposure Lover"? That's the only AE
acronymI know of in imaging.)
You need to look into demosaicing algorithms. They do exactly what
you want.
http://www.google.com/search?hl=en&q=demosaicing+algorithms
Regards,
ImageAnalyst
aruzinsky
> But why can't you interpolate in a more intelligent way? You go
> around the clock in the direction that is closest, so the average of 0
> and 359 would be 359.5 (still a red), and the average of 0 and 240
> would be 300 (rather than 120) which is a purple which seems like it
>
> - Show quoted text -
What do you propose to do with red, H=0, versus cyan, H=180? Either
midpoint yellow-green, H = 90 or purple, H = 270, is visually
undesireable.
RGB Bilinear 5X red vs. cyan: http://www.general-cathexis.com/images/rgbBilinear5X.png
HSI Bilinear 5X red vs. cyan: http://www.general-cathexis.com/images/hsiBilinear5X.png
HSI other way around Bilinear 5X: http://www.general-cathexis.com/images/hsi2Bilinear5X.png
Harris
@k37g2000hsf.googlegroups.com:
Since resizing is a spatial transformation, it should be invariant to intensity levels (mono or RGB).
Hence, it should not really matter if you do 3x (RGB) or 1x resizing (mono). On the other hand,
interpolation errors on reparate RGB channels may produce a new (combined) pixel value slightly
different of the original one, leading to a color-distorted image (probably in the form of small color shifts
at pixel-level scales).
My advice would be: (1) store the RGB ratios for each pixel, i.e., keep the original image, (2) convert
the image into intensity matrix using a standard (linear) formula, (3) resize the intensity matrix, (4)
convert the intensity matrix back to RGB using the values/ratios for each pixel form the original image.
The single-channel approach cuts down your processing time almost to a factor of one-third (plus
RGB conversions). Of course, you also need a mapping from the original to the new pixels (1 pixel ->
N pixels), so it is much simpler if you use integer multipliers in resizing (e.g. x2, x3, etc).
--
Harris
ImageAnalyst
>
> - Show quoted text -
I don't propose anything because there are cases where there are no
visually acceptable interpolated colors, as you proved. So there are
times when it doesn't "work" and there are times when it does.
Mathematically it can be done but it's up to the use to say what is
acceptable or unacceptable in their situation.
Regards,
ImageAnalyst
aruzinsky
> AE lover <aelove...@gmail.com> wrote in news:2a03e221-19de-4e85-81d1-0b0e3ee4d7e3
Let me paraphrase that:
1. Y = a*R + b*G + c*B + d, (d is small positive number to prevent
division by zero)
2. ratioR = R/Y, ratioG = G/Y, ratioB = B/Y
3. Interpolate: Y' = bilinear(Y), ratioR' = box(ratioR), ratioG' =
box(ratioG), ratioB' = box(ratioB)
4. R' = Y'*ratioR', G' = Y'*ratioG', B' = Y'*ratioB'
Bilinear interpolation on RGB is faster than these conversions.
I will digress here and say it that it is bad practice to put one's
thoughts ahead of empiricism. This is an ethical issue because it is
a major cause of chaos in society.
I know from experience that you can do fancy interpolation on the Y
channel of YCbCr space and sloppy interpolation on th Cb and Cr
channels, but "fancy" here is nonlinear and relatively slow.
aruzinsky
AFter giving it more thought, I expect it is faster but not much.
The problem is with the result. Consider an edge with red hue on one
side and cyan hue on the other, both of equal Y. Your method will
produce a result that is the same as box interpolation of RGB.
When people look at linear enlargements, they associate the blur with
that of an unfocused eye lens because that is their life experience
with blur. A lens blurs different colors independently and that is
why linear enlargement should also do it independently. In the case
of a red-cyan edge, the eye expects the blurred edge to be grayish.
Of course, for nonlinear enlargement that preserves sharp edges, this
does not apply.
aruzinsky
>
> > - Show quoted text -
>
> ----------------------------------------------------------------------------
> visually acceptable interpolated colors, as you proved. So there are
> times when it doesn't "work" and there are times when it does.
> Mathematically it can be done but it's up to the use to say what is
> acceptable or unacceptable in their situation.
> Regards,
>
> - Show quoted text -
I proved no such thing. The RGB results are much more acceptable
because the typical human eye expects to see a grayish boundary
between red and cyan because that is what an unfocused lens does.
Blur is undesireable, but when it is unavoidable, it better resemble
natural blur.
Harris
news:0bf42d72-1f92-44df...@z66g2000hsc.googlegroups.com:
> Let me paraphrase that:
>
> 1. Y = a*R + b*G + c*B + d, (d is small positive number to prevent
> division by zero)
>
> 2. ratioR = R/Y, ratioG = G/Y, ratioB = B/Y
>
> 3. Interpolate: Y' = bilinear(Y), ratioR' = box(ratioR), ratioG'
>
> 4. R' = Y'*ratioR', G' = Y'*ratioG', B' = Y'*ratioB'
>
>
> Bilinear interpolation on RGB is faster than these conversions.
>
> I will digress here and say it that it is bad practice to put one's
> thoughts ahead of empiricism. This is an ethical issue because it is
> a major cause of chaos in society.
>
> I know from experience that you can do fancy interpolation on the Y
> channel of YCbCr space and sloppy interpolation on th Cb and Cr
> channels, but "fancy" here is nonlinear and relatively slow.
I really don't understand what your opinions (or mine) on social chaos has to do with image
processing. If you mean to say that I said a stupid thing just to look smart, then just say it.
My answer is this: bilinear is not a good interpolation method but it is fast. Since it works in 2D, it
requires 12 multiplications and 4 divisions per (new) pixel estimate. If you have any doubt, see:
http://en.wikipedia.org/wiki/Bilinear_interpolation. Your "paraphrase" of what I initially proposed is too
slow, because you don't really need all these conversions, only an intensity estimate (RGB -> mono)
and the original image:
(1). I(x,y) = a*R(x,y)+b*G(x,y)+c*B(x,y)
(2). apply bilinear interpolation on I(x,y)
(3). convert back to RGB
Step 2 is the same as above, e.g. 12 multiplications and 4 divisions for bilinear per (new) pixel value.
Step 3 can be implemented using the original channel value and the value range: if I'(x,y) is the
interpolated value, then new Red is: R'(x,y) = I'(x,y)/I(x,y) * R(x,y).
As you can see, you proposal with full RGB interpolation requires 3x (12.mul+4.div) = 36.mul + 12.div
per pixel, probably with floating-point arithmetic due to the use of ratios. My proposal requires 1x (3.mul
+ bilinear + 1.mul+1.div) = 16.mul+5.div per pixel, which can be implemented easily with integer
arithmetic in steps 1 and 3 (no explicit ratios used).
Please do the math before you criticise someone else's motives and knowledge here.
--
Harris
aruzinsky
On May 26, 4:31 am, Harris <xgeorg...@pathfinder.gr> wrote:
> aruzinsky <aruzin...@general-cathexis.com> wrote innews:0bf42d72-1f92-44df...@z66g2000hsc.googlegroups.com:
>
> > Let me paraphrase that:
>
> > 1. Y = a*R + b*G + c*B + d, (d is small positive number to prevent
> > division by zero)
>
> > 2. ratioR = R/Y, ratioG = G/Y, ratioB = B/Y
>
> > 3. Interpolate: Y' = bilinear(Y), ratioR' = box(ratioR), ratioG'
> > box(ratioG), ratioB' = box(ratioB)
>
> > 4. R' = Y'*ratioR', G' = Y'*ratioG', B' = Y'*ratioB'
>
> > Bilinear interpolation on RGB is faster than these conversions.
>
> > I will digress here and say it that it is bad practice to put one's
> > thoughts ahead of empiricism. This is an ethical issue because it is
> > a major cause of chaos in society.
>
> > I know from experience that you can do fancy interpolation on the Y
> > channel of YCbCr space and sloppy interpolation on th Cb and Cr
> > channels, but "fancy" here is nonlinear and relatively slow.
>
> I really don't understand what your opinions (or mine) on social chaos has to do with image
> processing. If you mean to say that I said a stupid thing just to look smart, then just say it.
>
You didn't answer my question. Regarding, "to look smart," it is bad
practice to speculate motives. Is this your confession?
>
> My answer is this: bilinear is not a good interpolation method but it is fast. Since it works in 2D, it
> requires 12 multiplications and 4 divisions per (new) pixel estimate.
> If you have any doubt, see:http://en.wikipedia.org/wiki/Bilinear_interpolation.
That doesn't apply to enlargement because the problem is separable and
performed as 2 1D interpolations. Assume input is m x n and output is
M x N First, I calculate 2 weights per each x and 2 weights per each
y coordinate in the output; this is an O(M + N) calculation which is
speed-wise negligible. Then I form an m x N image which involves only
2 multiplications and 1 addition per greyscale pixel. Then, using the
m x N image as input I repeat forming an M x N image. The operations
counts are
m*N*( 2 mult + 1 add) + M*N*(2 mult + 1 add) =
(M + m)*N*(2 mult + 1 add)
Thus, you have slightly more that 2 multiplications and 1 addition per
greyscale pixel. (Actually, although I do indeed do it this way, this
is the first time I have done an operations count. Seems too fast. I
previously thought it involved 4 multiplications. Maybe, I made a
mistake. But, it is not going to change my method of calculation)
> Your "paraphrase" of what I initially proposed is too
> slow, because you don't really need all these conversions, only an intensity estimate (RGB -> mono)
> and the original image:
>
> (1). I(x,y) = a*R(x,y)+b*G(x,y)+c*B(x,y)
> (2). apply bilinear interpolation on I(x,y)
> (3). convert back to RGB
>
> Step 2 is the same as above, e.g. 12 multiplications and 4 divisions for bilinear per (new) pixel value.
> Step 3 can be implemented using the original channel value and the value range: if I'(x,y) is the
> interpolated value, then new Red is: R'(x,y) = I'(x,y)/I(x,y) * R(x,y).
1. You will end up dividing by zero when I(x,y) = 0. There is some
computation overhead to avoid this.
2. There is some computation overhead in finding nearest neighbor.
> As you can see, you proposal with full RGB interpolation requires 3x (12.mul+4.div) = 36.mul + 12.div
WRONG. WRONG. WRONG. Slightly more than 6 multiplications and 3
additions.
> per pixel, probably with floating-point arithmetic due to the use of ratios. My proposal requires 1x (3.mul
> + bilinear + 1.mul+1.div) = 16.mul+5.div per pixel, which can be implemented easily with integer
> arithmetic in steps 1 and 3 (no explicit ratios used).
>
> Please do the math before you criticise someone else's motives and knowledge here.
>
> --
> Harris- Hide quoted text -
>
> - Show quoted text -
I didn't criticize your motives because I don't know them. Answer my
question, were you speaking from experience? If not, you should at
least tell the OP that you are speculating.
Dave Martindale
>It depends on what you think your image channels will be, and how to make
>use of their correlation. A typical way to do that is to first transform
>them to a different color space, for example YUV. The transformation between
>YUV (and related other spaces) is linear, and the bilinear interpolation
>filter is linear as well, but in a different dimension. This means that
>it actually makes *no* difference at all whether you first transform to
>YUV, run there a bilinear filter, then transform back, or run the bilinear
>filter on RGB itself. The result will be the same. But *only* because
>bilinear filtering is linear, and YUV to RGB is a linear transformation.
So far so good.
>If you pick a nonlinear color space (say, CIElab) and/or a nonlinear
>filter (say, bicubic), things will be not so easy and the results will
>be different.
There's no problem with using a bicubic filter for resampling. Although
it is based on cubic polynomials instead of linear polynomials, the
process of resampling with a cubic is still a *linear transformation*.
So the entire process of colour transform/interpolate/colour transform
is still linear, in the linear transformation sense, and the choice of
colour space doesn't make any difference to the result. (You won't get
the same result as bilinear filtering, but the same result as the same
bicubic filter applied in another colour space).
On the other hand, a nonlinear representation *will* change the results,
often visibly. For example, a linear filter (in the linear transform
sense, even if it's using cubic polynomials) will generally have a DC
gain of one, so it leaves the average brightness of the image unchanged,
or (more precisely) the mean pixel value will remain constant. In a
nonlinear representation, keeping the sum of pixel values the same does
not generally keep the brightness the same.
Despite this, linear filters (e.g. resizing, Gaussian blur, unsharp
mask) are often applied to nonlinear (gamma-corrected) data, usually
with pleasing results.
There are non-linear filters too - many noise-reducing and
edge-detecting filters are nonlinear (in the linear transform sense).
Dave
Dave Martindale
>My answer is this: bilinear is not a good interpolation method but it is
>fast. Since it works in 2D, it
>requires 12 multiplications and 4 divisions per (new) pixel estimate. If
>you have any doubt, see:
>http://en.wikipedia.org/wiki/Bilinear_interpolation. Your "paraphrase"
>of what I initially proposed is too
>slow, because you don't really need all these conversions, only an
>intensity estimate (RGB -> mono)
>and the original image:
>(1). I(x,y) = a*R(x,y)+b*G(x,y)+c*B(x,y)
>(2). apply bilinear interpolation on I(x,y)
>(3). convert back to RGB
>Step 2 is the same as above, e.g. 12 multiplications and 4 divisions for
>bilinear per (new) pixel value.
>Step 3 can be implemented using the original channel value and the value
>range: if I'(x,y) is the
>interpolated value, then new Red is: R'(x,y) = I'(x,y)/I(x,y) * R(x,y).
The problem I see with this is that you're effectively calculating the
higher-resolution image by recombining a luminance/intensity image
that was obtained by linear interpolation and colour information that
was upsampled by nearest-neighbour. The latter is a terrible upsampling
method that doesn't actually interpolate anything.
In the case where the original has two adjacent pixels of similar
colour but different intensity, the larger output image will smoothly
interpolate that intensity across the original one-pixel distance.
But if the two pixels have the same intensity but different colour,
there will be an abrupt colour change half-way along a line between the
two original pixel locations. So the colour component of the image will
have some nasty artifacts in it.
Now, you can argue that under certain viewing conditions, your eye's
colour resolution is bad enough that you can't see the colour artifacts,
so they don't matter. True. But you will get an image that looks
significantly worse up-close than interpolating in all 3 components
(whether that's in RGB or YCbCr).
>My proposal requires 1x (3.mul
>+ bilinear + 1.mul+1.div) = 16.mul+5.div per pixel, which can be
>implemented easily with integer
>arithmetic in steps 1 and 3 (no explicit ratios used).
Another problem is that division is generally *much* slower than other
operations, even multiplication, so it's worth avoiding whenever
possible. Standard convolution-based resizing uses lots of multiplies
and adds but no division at all. Throw in a few divisions, and you may
take longer to get a result even with a fraction of the number of
operations total.
In addition, much hardware these days can do a multiply-accumulate
operation as fast as a multiply alone, and sometimes it can do 4
multiply-add operations on suitably-arranged vector data as fast as a
single multiply on scalar data. What is fast and what is slow depends
on how well the computation fits the available hardware.
Dave
Thomas Richter
>> If you pick a nonlinear color space (say, CIElab) and/or a nonlinear
>> filter (say, bicubic), things will be not so easy and the results will
>> be different.
>
> There's no problem with using a bicubic filter for resampling. Although
> it is based on cubic polynomials instead of linear polynomials, the
> process of resampling with a cubic is still a *linear transformation*.
I stand corrected, you're right. The interpolation is still a linear
function of the input samples indeed, so no problem here either (it
doesn't matter which linear color space you pick here).
We agree otherwise, no further comments on my side.
So long,
Thmas
aruzinsky
> Harris <xgeorg...@pathfinder.gr> writes:
> > ...
>
> The problem I see with this is that you're effectively calculating the
> higher-resolution image by recombining a luminance/intensity image
> that was obtained by linear interpolation and colour information that
> was upsampled by nearest-neighbour. The latter is a terrible upsampling
> method that doesn't actually interpolate anything.
>
> there will be an abrupt colour change half-way along a line between the
> two original pixel locations. So the colour component of the image will
> have some nasty artifacts in it.
>
> Now, you can argue that under certain viewing conditions, your eye's
> colour resolution is bad enough that you can't see the colour artifacts,
> so they don't matter. True. But you will get an image that looks
> significantly worse up-close than interpolating in all 3 components
> (whether that's in RGB or YCbCr).
>
In Harris's defense, it won't look "terrible" or "significantly worse"
but just bad enough to negate the advantage of the computation savings
which are much smaller than he imagines. The eye is relatively
insensitive to inaccuracies in the Cb and Cr channels and that is why
they are compressed more than Y in JPEG. I have used schemes similar
to Harris's for Xin Li (NEDI) enlargement. In NEDI, counterparts to
bilinear weights are calculated Wiener style which is very time
consuming. I calculate the weights based only on the Y channel and
apply them to all three channels, Y, Cb, Cr. It is good enough
considering the ~2/3 time savings. However, my default weights for
homogeneous Y are bilinear and not nearest neighbor as in Harris's
case.
aruzinsky
>
> - Show quoted text -
Here is why one should not put theory ahead of empiricism:
1. Input Image: http://www.general-cathexis.com/interpolation/clown.png
2. 4X Bilinear on RGB channels: http://www.general-cathexis.com/images/clown4Xbilinear.jpg
3. 4X Bilinear on Y, Nearest Neighbor on R/Y etc. :
http://www.general-cathexis.com/images/clown4XbilinearYRatio.jpg
4. 4X Bilinear on Y, Nearest Neighbor on Cb and Cr:
http://www.general-cathexis.com/images/clown4XbilinearYboxCbCr.jpg
The Y here is Y = (R+G+B)/3. Conventional YCbCr gave worse results
for 3.
This was done with SAR Image Processor with no additional
programming. You can verify these results with free SAR save disabled
demo. No. 3 involved circuitous calculations involving log RGB color
space where division is subtraction and multiplication is addition. I
mention this because the No. 3 result should be checked. 3 is the
worse result. If you look below the triangular white area of the
right car, you will see bright red streaks. No. 4 is almost
indistinguishable from 2.
In hindsight, if Harris's ratios were a good idea, they would probably
be used in lossy image compression instead of Cb and Cr.
illywhacker
>
> - Show quoted text -
Since no one has stooped to defining a criterion of optimality here,
there is no empiricism, from you or anyone else. Unless your opinion
on how good it looks is the deciding factor of course.
illywhacker;
Harris
news:5f90d431-efc6-4ce2...@c58g2000hsc.googlegroups.com:
>> If you have any doubt,
>> see:http://en.wikipedia.org/wiki/Bilinear_interpola
> tion.
>
> That doesn't apply to enlargement because the problem is separable and
> performed as 2 1D interpolations. Assume input is m x n and output is...........
> ............
I hope you understand the fault in your thinking. Resize is non-separable oprtation in 2D because you
have to take into account a "box" instead of a "line" - this why the linear interpolation is called "bi-
linear" and no just linear. What you are describing will not work if the contents of the image are
correlated statistically in both directions, since artificially separable operations usually cause
discontinuities in the resulting image (similar to the jpeg "block" artifacts). Still, you may choose to use
that, if you feel there is some other application-specific advantage (e.g. speed?)
>
> In hindsight, if Harris's ratios were a good idea, they would probably
> be used in lossy image compression instead of Cb and Cr.
>
I usually don't write follow-ups in my Usenet posts because sometimes it seems like flaming someone
(which I never do). I would never suggest nearest neighbor or bilinear for serious image resizing,
especially for upscaling. Furthermore, lossy image compression has nothing to do with image resize.
My "optimality" criterion regarding my posts here were entirely towards speed and ease of code
optimization (less divisions, more integer operations).
Everyone who has spent years working in this field (professionally or academically) knows the
advantages and disadvantages of each method, there is no point discussing things that are easily
available in any good textbook in signal/image processing.
--
Harris
aruzinsky
> aruzinsky <aruzin...@general-cathexis.com> wrote innews:5f90d431-efc6-4ce2...@c58g2000hsc.googlegroups.com:
>
> >> If you have any doubt,
> >> see:http://en.wikipedia.org/wiki/Bilinear_interpola
> > tion.
>
> > That doesn't apply to enlargement because the problem is separable and
> > performed as 2 1D interpolations. Assume input is m x n and output is...........
> > ............
>
> I hope you understand the fault in your thinking. Resize is non-separable oprtation in 2D because you
> have to take into account a "box" instead of a "line" - this why the linear interpolation is called "bi-
> linear" and no just linear. What you are describing will not work if the contents of the image are
> correlated statistically in both directions, since artificially separable operations usually cause
> discontinuities in the resulting image (similar to the jpeg "block" artifacts). Still, you may choose to use
> that, if you feel there is some other application-specific advantage (e.g. speed?)
>
The fault in your thinking is that you ignore the reality of what I
do. I indeed do bilinear interpolation as a separable operation and
the results are exactly the same as for doing it as a non-separable
operation. It does not depend on the image. You are denying reality
and preferring your thoughts in the manner of a schizophrenic.
>
>
> > In hindsight, if Harris's ratios were a good idea, they would probably
> > be used in lossy image compression instead of Cb and Cr.
>
> I usually don't write follow-ups in my Usenet posts because sometimes it seems like flaming someone
> (which I never do). I would never suggest nearest neighbor or bilinear for serious image resizing,
> especially for upscaling. Furthermore, lossy image compression has nothing to do with image resize.
>
Seeing the relation requires intelligence and creativity.
> My "optimality" criterion regarding my posts here were entirely towards speed and ease of code
> optimization (less divisions, more integer operations).
>
Then just use nearest neighbor.
> Everyone who has spent years working in this field (professionally or academically) knows the
> advantages and disadvantages of each method, there is no point discussing things that are easily
> available in any good textbook in signal/image processing.
>
And, that would be who?
aruzinsky
>
> - Show quoted text -
Wrong. Here the criterion of optimality is operation counts. I have
implemented bilinear interpolation in the manner I described. It
exists. It is reality. It is not hypothetical. It is not a plan.
Therefore it is empirical.
illywhacker
>
> - Show quoted text -
So if the criterion of optimality is operation counts, I have the best
possible algorithm: do nothing!
illywhacker;
illywhacker
>
> - Show quoted text -
What matters is whether the result is good according to some
criterion. I am not expressing an opinion on your method. If the sole
criterion is operation counts, then why not simply duplicate pixel
values? Thought not: ergo, there is some other definition of
optimality that has not been stated. Until it is stated, no result can
be evaluated as better or worse than another.
illywhacker;
aruzinsky
I never said "sole" criterion; Harris did. Harris said, "My
optimality criterion regarding my posts here were entirely towards
speed and ease of code optimization (less divisions, more integer
operations)." I responded, "Then just use nearest neighbor."
> Thought not: ergo, there is some other definition of
> optimality that has not been stated. Until it is stated, no result can
> be evaluated as better or worse than another.
>
> illywhacker;- Hide quoted text -
>
> - Show quoted text -
It is stated but you didn't quote it. I said "Here the criterion of
optimality is operation counts." "Here" refers to the post you
quoted. I made another post in which I made quality an issue, but you
did not quote that post. Regarding that post, I made the images
(empirical results) available to viewers so that they could decide
according to their personal quality criterion. Furthermore, I made it
relatively easy to verify my results. I may have abbreviated my
personal quality evaluation in such a way that it inadvertently
sounded objective, but, at worse, it had the effect of leading
witnesses which is nowhere nearly as bad keeping them non-
witnesses.
Harris
news:fd2d6ca5-3fa8-44e2...@34g2000hsf.googlegroups.com:
>
> The fault in your thinking is that you ignore the reality of what I
> do. I indeed do bilinear interpolation as a separable operation and
> the results are exactly the same as for doing it as a non-separable
> operation. It does not depend on the image. You are denying reality
> and preferring your thoughts in the manner of a schizophrenic.
>
Original image sample:
1 2
3 4
Your 2-pass 1-D linear interpolation expands this box twice, once for X-direction and once for Y-
direction. The new pixels at position (area) 4 are interpolated using 3 and 2 respectively, that is using
distance 1. But the distance from 1, which should also be taken into account statistically, is at
distance sqrt(2). Even if you are using weighting factors, you end up with something else (weighted
average) other than true bilinear interpolation.
You cannot learn anything if you think you have it all figured out much more cleverly that anyone else.
This is the first thing I tell my "wiseguys" students at the University.
Read a book and learn to reply more politely.
--
Harris
Martin Leese
> Original image sample:
>
> 1 2
> 3 4
>
> Your 2-pass 1-D linear interpolation expands this box twice, once for X-direction and once for Y-
> direction. The new pixels at position (area) 4 are interpolated using 3 and 2 respectively, that is using
> distance 1. But the distance from 1, which should also be taken into account statistically, is at
> distance sqrt(2). Even if you are using weighting factors, you end up with something else (weighted
> average) other than true bilinear interpolation.
Sorry to interrupt, but bi-linear interpolation
is separable. Always has been, always will be.
If you still doubt this then ten minutes with
pen and paper will convince you otherwise.
We now return you to your scheduled flame-fest.
--
Regards,
Martin Leese
E-mail: ple...@see.Web.for.e-mail.INVALID
Web: http://members.tripod.com/martin_leese/
illywhacker
Ah. Ambiguity, ambiguity.
> I made another post in which I made quality an issue, but you
> did not quote that post. Regarding that post, I made the images
> (empirical results) available to viewers so that they could decide
> according to their personal quality criterion.
Very good.
> I may have abbreviated my
> personal quality evaluation in such a way that it inadvertently
> sounded objective
OK then. We agree.
illywhacker;
Harris
news:aKr%j.405$cV.142@edtnps92:
> Harris wrote:
>
>> Original image sample:
>>
>> 1 2
>> 3 4
>>
>> Your 2-pass 1-D linear interpolation expands this box twice, once for
>> X-direction and once for Y- direction. The new pixels at position
>> (area) 4 are interpolated using 3 and 2 respectively, that is using
>> distance 1. But the distance from 1, which should also be taken into
>> account statistically, is at distance sqrt(2). Even if you are using
>> weighting factors, you end up with something else (weighted average)
>> other than true bilinear interpolation.
>
> Sorry to interrupt, but bi-linear interpolation
> is separable. Always has been, always will be.
> If you still doubt this then ten minutes with
> pen and paper will convince you otherwise.
>
> We now return you to your scheduled flame-fest.
>
Wrong context, my mistake, I was referring to the proposed implementation. I was trying to explain
this:
http://www.dspguide.com/ch24/3.htm
No further posts form me on this, I promise
:-)
--
Harris
aruzinsky
wrote:
Remember the saying, "All that is necessary for evil to succeed is
that good men do nothing."? Replace "evil" with "stupidity". You
are a good man. Thank you.
aruzinsky
illywhacker;"
You are projecting.
--
Message posted using http://www.talkaboutgraphics.com/group/sci.image.processing/
More information at http://www.talkaboutgraphics.com/faq.html
illywhacker
wrote:
> "You pretentious, pompous, condescending prat.
>
Sorry? Ah. A Freudian.
illywhacker;