title: Custom erosion results do not match with OpenCV erosion
body: <p>I am new to image processing and was trying to write a custom method for erosion and dilation. I then tried to compare my results with OpenCV erosion and dilation function results. I give one padding of zeros to the input image and then overlap the kernel with padded image. Here is my function:</p>
  
  <pre><code>import numpy as np
  import matplotlib.pyplot as plt
  
  def operation(image, kernel, padding=0, operation=None):
      if operation:
          img_operated = image.copy() #this will be the image
  
          """
          The add_padding function below will simply add padding to the image, so the new array with one padding will
          look like -&gt;
  
          [[0,0,0,0,0,0,0,0],
           [0,0,0,1,1,1,1,0],
           [0,0,0,1,1,1,1,0],
           [0,1,1,1,1,1,1,0],
           [0,1,1,1,1,1,1,0],
           [0,1,1,1,1,0,0,0],
           [0,1,1,1,1,0,0,0],
           [0,0,0,0,0,0,0,0]]
           )
  
          """
          image = add_padding(image, padding)
  
          print("Image is \n",  image)
          print("kernel is \n",kernel)
          print("="*40)
  
          vertical_window = padded.shape[0] - kernel.shape[0] #final vertical window position
          horizontal_window = padded.shape[1] - kernel.shape[1] #final horizontal window position
  
          print("Vertical Window limit: {}".format(vertical_window))
          print("Horizontal Window limit: {}".format(horizontal_window))
          print("="*40)
  
          #start with vertical window at 0 position
          vertical_pos = 0
          values = kernel.flatten() #to compare with values with overlapping element for erosion
  
          #sliding the window vertically
          while vertical_pos &lt;= (vertical_window):
              horizontal_pos = 0
  
              #sliding the window horizontally
              while horizontal_pos &lt;= (horizontal_window):
                  dilation_flag = False
                  erosion_flag = False
                  index_position = 0
  
                  #gives the index position of the box
                  for i in range(vertical_pos, vertical_pos+kernel.shape[0]):
                      for j in range(horizontal_pos, horizontal_pos+kernel.shape[0]):
  
                          #First Case
                          if operation == "erosion":
                              if padded[i,j] == values[index_position]:
                                  erosion_flag = True
                                  index_position += 1
                              else:
                                  erosion_flag = False
                                  break
  
                          #Second Case
                          elif operation == "dilation":
                              #if we find 1, then break the second loop
                              if padded[i][j] == 1:
                                  dilation_flag = True
                                  break
  
                          else:
                              return  "Operation not understood!"
  
                      #if opertion is erosion and there is no match found, break the first 'for' loop
                      if opr == "erosion" and erosion_flag is False:
                          break
  
                      #if operation is dilation and we find a match, then break the first 'for' loop 
                      if opr == "dilation" and dilation_flag is True:
                          img_operated[vertical_pos, horizontal_pos] = 1
                          break
  
                  #Check whether erosion flag is true after iterating over one complete overlap 
                  if operation == "erosion" and erosion_flag is True:
                      img_operated[vertical_pos, horizontal_pos] = 1
  
                  elif operation == "erosion" and erosion_flag is False:
                      img_operated[vertical_pos, horizontal_pos] = 0
  
                  #increase the horizontal window position
                  horizontal_pos += 1
  
              #increase the vertical window position
              vertical_pos += 1
  
          return img_operated
  
      return "Operation Required!"
  
  array = np.array([[0,0,1,1,1,1],
                 [0,0,1,1,1,1],
                 [1,1,1,1,1,1],
                 [1,1,1,1,1,1],
                 [1,1,1,1,0,0],
                 [1,1,1,1,0,0]], dtype=np.uint8)
  
  kernel = np.array ([[0, 1, 0],
                      [1, 1, 1],
                      [0, 1, 0]], dtype = np.uint8)
  
  #image will be padded with one zeros around
  result_erosion = operation(array, kernel, 1, "erosion")
  result_dilation = operation(array, kernel, 1, "dilation")
  
  #CV2 Erosion and Dilation
  cv2_erosion = cv2.erode(array, kernel, iterations=1) 
  cv2_dilation = cv2.dilate(array, kernel, iterations=1)
  
  </code></pre>
  
  <p>The dilation result matches but the erosion result does not. I am not sure why this is the case. Is it because of some padding issues? Does OpenCV pad the image? Or am I implementing the erosion method incorrectly? Here is the image of the results:</p>
  
  <p><a href="https://i.stack.imgur.com/5uO6B.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/5uO6B.png" alt="final results"></a></p>