Hi All, I'm trying to iterate through each pixel in a view and calculate the average of the 9x9 pixels surrounding it. I initially tried following the convolution example, but it's performance isn't fast enough for my needs. I have tried several ways of iterating through the pixels on the 136x98 test image provided with the gil: attempt #1 executes in ~400 ms convolve_rows_fixed(src1,kernel,dst); convolve_cols_fixed(dst,kernel,dst); attempt #2 executes in ~26000 ms vector window(windowSizeX, vector<double> (windowSizeY, 1.0 / 81)); for (int y = 0; y <= src1.height(); ++y) { for (int x = 0; x < src1.width(); ++x) { for (int yi = y - windowRadiusY; yi <= y + windowRadiusY; ++yi) { if (yi >= 0 && yi <= src1.height()) { typename SrcView1::x_iterator src1_it=src1.row_begin(y); typename SrcView2::x_iterator src2_it=src2.row_begin(y); typename DstView::x_iterator dst_it=dst.row_begin(y); for (int xi = x - windowRadiusX; xi <= x + windowRadiusX; ++xi) { vector<double> ux, ux2, uy, uy2, uxy = vector<double>(numChannels, 0); ux = ux2 = uy = uy2 = uxy; if (xi >= 0 && xi <= src1.width()) { int winX = xi - x + windowRadiusX; int winY = yi - y + windowRadiusY; double winTotal = 0; for (int c = 0; c < numChannels; ++c) { ux[c] += window[winX][winY] * typename SrcView1::value_type(src1_it[xi])[c]; winTotal += window[winX][winY]; } // Normalize calculation for (int c = 0; c < numChannels; ++c) { ux[c] = ux[c] / winTotal; } } } } } } } So now I'm attempting to run the following but having trouble: ... template double function(const SrcView1& src1, const SrcView2& src2, const DstView& dst) { typedef typename channel_type<DstView>::type dstChannelType; transform_pixel_positions(src1, src2, dst, operator<dstChannelType>()); } ... template <typename Out> struct operator { template <typename T> Out operator()(const T& in1, const T& in2) const { rgb8_view_t subView1 = rgb8_view_t(9,9,in1); // in1 throws type mismatch rgb8_view_t subView2 = rgb8_view_t(9,9,in2); // in2 throws type mismatch Out retVal; transform_pixels(subView1, subView2, retVal, average()); return rgb8_pixel_t(0,0,0); } }; Can you explain if this is an appropriate way to construct a subview and how I can retrieve the locator needed as the 3rd parameter to rgb8_view_t(), specifically I need the locator for 4 pixels left and 4 pixel up so that the average window is centered on in1/in2? Also, is it possible to get the view type from the locator inputs in1 and in2 so that I can change the subView instantiantion to in1Type subView1 = in1Type(9,9,in1)? It seems that the performance, with regard to speed, is much better using transform_pixel or transform_pixel_positions over iterating through the pixels myself unless I am doing something incorrect. Are there any other programming styles that provide better performance for doing similar calculations on groups of pixels? As always, I greatly appreciate any help as I'm learning. Thanks, Mark Sapp Notice: This e-mail is intended solely for use of the individual or entity to which it is addressed and may contain information that is proprietary, privileged, company confidential and/or exempt from disclosure under applicable law. If the reader is not the intended recipient or agent responsible for delivering the message to the intended recipient, you are hereby notified that any dissemination, distribution or copying of this communication is strictly prohibited. If this communication has been transmitted from a U.S. location it may also contain data subject to the International Traffic in Arms Regulations or U.S. Export Administration Regulations and cannot be disseminated, distributed or copied to foreign nationals, residing in the U.S. or abroad, without the prior approval of the U.S. Department of State or appropriate export licensing authority. If you have received this communication in error, please notify the sender by reply e-mail or collect telephone call and delete or destroy all copies of this e-mail message, any physical copies made of this e-mail message and/or any file attachment(s).