code: private static void compute(float[] matrix,
                                  int[] in,
                                  int[] out,
                                  int x,
                                  int index,
                                  int ioffset,
                                  int cols2,
                                  int width,
                                  boolean alpha,
                                  int edge)
      {
          float r = 0;
          float g = 0;
          float b = 0;
          float a = 0;
  
          final int moffset = cols2;
          for (int col = -cols2; col <= cols2; col++)
          {
              final float f = matrix[moffset + col];
              if (Double.doubleToRawLongBits(f) != 0L)
              {
                  final int ix = checkEdge(width, x, col, edge);
                  final int rgb = in[ioffset + ix];
                  a += f * (rgb >> Constant.BYTE_4 & 0xFF);
                  r += f * (rgb >> Constant.BYTE_3 & 0xFF);
                  g += f * (rgb >> Constant.BYTE_2 & 0xFF);
                  b += f * (rgb & 0xFF);
              }
          }
          final int ia;
          if (alpha)
          {
              ia = clamp((int) (a + Constant.HALF));
          }
          else
          {
              ia = 0xFF;
          }
          final int ir = clamp((int) (r + 0.5));
          final int ig = clamp((int) (g + 0.5));
          final int ib = clamp((int) (b + 0.5));
          out[index] = ia << Constant.BYTE_4 | ir << Constant.BYTE_3 | ig << Constant.BYTE_2 | ib;
      }
docs: Compute blur point.
  
  @param matrix The matrix used.
  @param in The source pixels.
  @param out The destination pixels.
  @param x The current horizontal index.
  @param index The current vertical index.
  @param ioffset The index offset.
  @param cols2 The half matrix width.
  @param width The image width.
  @param alpha The alpha flag.
  @param edge The edge flag.