ewellenr/receipt_indexer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Whiteoutbackground update checkpoint.

Browse Source 
Using lab a and b channels (although it hasn't worked too well yet.

Signed-off-by: Ethan Wellenreiter <ewellenreiter@gmail.com>
This commit is contained in:
Ethan Wellenreiter 2023-11-17 16:23:07 -05:00
parent fc2de6ed4f
commit c2ca87eea5
2 changed files with 332 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

448
code/autocropper/houghlinedevspace.ipynb
View File

@ -2,7 +2,7 @@
"cells": [
{
"cell_type": "code",
"execution_count": 20,
"execution_count": 3033,
"metadata": {},
"outputs": [],
"source": [
@ -15,12 +15,13 @@
},
{
"cell_type": "code",
"execution_count": 21,
"execution_count": 3034,
"metadata": {},
"outputs": [],
"source": [
"import os\n",
"import pathlib\n",
"import time\n",
"\n",
"def removeextensionandnumeric(filename):\n",
" suffix = pathlib.Path(filename).suffix\n",
@ -36,20 +37,25 @@
" filenames.sort(key=removeextensionandnumeric)\n",
" # print(filenames)\n",
" outs = []\n",
" tdiffs = []\n",
" for filename in filenames:\n",
" suffix = pathlib.Path(filename).suffix\n",
" if (suffix not in imagefileextensions):\n",
" print(\"Not a valid image \"+filename)\n",
" continue\n",
" img = cv2.imread(pathtodataset+filename)\n",
" t1 = time.time()\n",
" outs.append(function(img))\n",
" tdiffs.append(time.time() - t1)\n",
" tdiffs = np.array(tdiffs)\n",
" print(\"average time: \" + str(np.mean(tdiffs))+\"(s)\")\n",
" return outs\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 22,
"execution_count": 3035,
"metadata": {},
"outputs": [],
"source": [
@ -71,7 +77,7 @@
},
{
"cell_type": "code",
"execution_count": 23,
"execution_count": 3036,
"metadata": {},
"outputs": [],
"source": [
@ -85,42 +91,306 @@
},
{
"cell_type": "code",
"execution_count": 24,
"execution_count": 3037,
"metadata": {},
"outputs": [],
"source": [
"img = cv2.imread('/mnt/dataset/baseimages/11.jpg')\n",
"# img = cv2.imread('/mnt/code/autocropper/test_images/IMG_7605.jpg')"
"img = cv2.imread('/mnt/dataset/baseimages/12.jpg')\n",
"# img = cv2.imread('/mnt/code/autocropper/test_images/IMG_7605.jpg')\n",
"testall = False"
]
},
{
"cell_type": "code",
"execution_count": 25,
"execution_count": 3038,
"metadata": {},
"outputs": [],
"source": [
"def whiteoutbackground(image):\n",
" sdim = int(min(image.shape[0], image.shape[1])/10)\n",
" skernel = cv2.getStructuringElement(cv2.MORPH_RECT, (sdim, sdim))\n",
" srkernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (sdim, sdim))\n",
" \n",
" \n",
" lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)\n",
" \n",
" imglist = []\n",
" imglist.append(image)\n",
" \n",
" # currentimgofatype = lab[:,:,0]\n",
" # imglist.append(currentimgofatype)\n",
" # imglist.append(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY))\n",
" laba = lab[:,:,1]\n",
" # imglist.append(currentimgofatype)\n",
" labb = lab[:,:,2]\n",
" # imglist.append(currentimgofatype)\n",
"\n",
"\n",
" blurimage1 = cv2.blur(laba, (5,5))\n",
" blurimage2 = cv2.blur(labb, (5,5))\n",
" \n",
" window = lab.shape[1]//5\n",
" if window % 2 == 0:\n",
" window += 1\n",
" thresh1 = cv2.adaptiveThreshold(blurimage1, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, window, 0)\n",
" window = lab.shape[1]//10\n",
" if window % 2 == 0:\n",
" window += 1\n",
" thresh2 = cv2.adaptiveThreshold(blurimage2, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, window, 0)\n",
" imglist.append(thresh1)\n",
" imglist.append(thresh2)\n",
" threshmerge = cv2.bitwise_or(thresh1, thresh2)\n",
" imglist.append(threshmerge)\n",
" \n",
" dim = int(min(threshmerge.shape[0], threshmerge.shape[1])/100)\n",
" # dim = 2\n",
" # dim = dotsize\n",
" kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (dim, dim))\n",
" \n",
" padthresh = mf.padWithColour(threshmerge, sdim, sdim, fill=255)\n",
" mask1t = cv2.morphologyEx(padthresh, cv2.MORPH_OPEN, kernel, iterations=1)\n",
" # mask1t = cv2.morphologyEx(mask1t, cv2.MORPH_OPEN, skernel)\n",
" imglist.append(mask1t)\n",
" \n",
" contours, heirarchy = cv2.findContours(255-mask1t, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
" biggestcontour = max(contours, key=cv2.contourArea)\n",
" \n",
" blank = np.full(threshmerge.shape, 255, dtype=np.uint8)\n",
" mask1 = blank.copy()\n",
" mask1 = mf.padWithColour(mask1, sdim, sdim, fill=255)\n",
" mask1 = cv2.drawContours(mask1, [biggestcontour], -1, 0, thickness=cv2.FILLED)\n",
" # temp = cv2.drawContours(image, [biggestcontour], -1, 255, thickness=3)\n",
" # imglist.append(temp)\n",
" imglist.append(mask1)\n",
" \n",
" mask1 = cv2.morphologyEx(mask1, cv2.MORPH_CLOSE, srkernel, iterations=2)\n",
" # mask1 = cv2.morphologyEx(mask1, cv2.MORPH_CLOSE, skernel, iterations=2)\n",
" mask1 = cv2.morphologyEx(mask1, cv2.MORPH_OPEN, srkernel)\n",
" # mask1 = cv2.morphologyEx(mask1, cv2.MORPH_CLOSE, skernel, iterations=2)\n",
" mask1 = mask1[sdim:-sdim, sdim:-sdim]\n",
" imglist.append(mask1)\n",
" \n",
" maskc = cv2.cvtColor(mask1, cv2.COLOR_GRAY2BGR)\n",
" whitedbackground = cv2.bitwise_or(image, maskc)\n",
" imglist.append(whitedbackground)\n",
" return whitedbackground\n",
" \n",
" \n",
" return imglist\n",
" \n",
" \n",
" \n",
" # contours, heirarchy = cv2.findContours(255-threshmerge, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
" # biggestcontour = max(contours, key=cv2.contourArea)\n",
" \n",
" # blank = np.full(threshmerge.shape, 255, dtype=np.uint8)\n",
" # mask1 = blank.copy()\n",
" # mask1 = cv2.drawContours(mask1, [biggestcontour], -1, 0, thickness=cv2.FILLED)\n",
" # # temp = cv2.drawContours(image, [biggestcontour], -1, 255, thickness=3)\n",
" # # imglist.append(temp)\n",
" \n",
" # mask1 = mf.padWithColour(mask1, sdim, sdim, fill=255)\n",
" \n",
" # mask1 = cv2.morphologyEx(mask1, cv2.MORPH_CLOSE, skernel, iterations=1)\n",
" # mask1 = cv2.morphologyEx(mask1, cv2.MORPH_OPEN, skernel)\n",
" # mask1 = mask1[sdim:-sdim, sdim:-sdim]\n",
" # imglist.append(mask1)\n",
" \n",
" # mask1merge = cv2.bitwise_and(mask1, mask1t)\n",
" # imglist.append(mask1merge)\n",
" \n",
" \n",
" \n",
" # maskc = cv2.cvtColor(mask1merge, cv2.COLOR_GRAY2BGR)\n",
" # # return maskc\n",
" # # return blurimage\n",
" # # print(blurimage)\n",
" # # print(maskc)\n",
" # whitedbackground = cv2.bitwise_or(image, maskc)\n",
" # imglist.append(whitedbackground)\n",
"\n",
" # return imglist\n",
" \n",
" \n",
" imagecpy = image.copy()\n",
" gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
" blurimage = cv2.blur(imagecpy, (13,13))\n",
" \n",
"\n",
" \n",
" \n",
" # ogcover = np.full(imagecpy.shape, 0, dtype=np.uint8)\n",
" # ogcover = mf.padWithColour(ogcover, sdim, sdim, fill=(255,255,255))\n",
" # ogcover = cv2.cvtColor(ogcover, cv2.COLOR_BGR2GRAY)\n",
" \n",
" # blurimage = mf.padWithColour(blurimage, sdim, sdim, fill=(255,255,255))\n",
" # imagecpy = cv2.inpaint(blurimage, ogcover, 3, cv2.INPAINT_TELEA)\n",
" # imagecpy = cv2.copyMakeBorder(blurimage, sdim, sdim, sdim, sdim, cv2.BORDER_REPLICATE)\n",
" # return imagecpy\n",
" # imagecpy = mf.padWithColour(image, hpadding=sdim, vpadding=sdim)\n",
" gray = cv2.cvtColor(blurimage, cv2.COLOR_BGR2GRAY)\n",
" \n",
" # blur = cv2.blur(gray, (7,7))\n",
" \n",
" # window = 51\n",
" window = gray.shape[1]//8\n",
" window = gray.shape[1]//15\n",
" if window % 2 == 0:\n",
" window += 1\n",
" thresh = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, window, 2)\n",
" thresh = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, window, 5)\n",
" # thresh2 = cv2.threshold(gray, 0, 255, cv2.THRESH_OTSU)[1]\n",
" # thresh = cv2.bitwise_and(thresh1, thresh2)\n",
" # return thresh\n",
" \n",
" # initialcontours, heirarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
" \n",
" # contourrects = np.array([list(cv2.boundingRect(contour)) for contour in initialcontours])\n",
" # rectdims = contourrects[:,2:]\n",
" # flatrectdims = rectdims.flatten()\n",
" # dotsize = int(np.median(flatrectdims)//2)\n",
" # # print(contourrects)\n",
" # # print(rectdims)\n",
" # # print(dotsize)\n",
" \n",
" \n",
"\n",
" # dim = int(min(thresh.shape[0], thresh.shape[1])/400)\n",
" dim = 2\n",
" # dim = dotsize\n",
" kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (dim, dim))\n",
" morphedthresh = cv2.morphologyEx(thresh, cv2.MORPH_ERODE, kernel)\n",
" # return morphedthresh\n",
" \n",
" \n",
" contours, heirarchy = cv2.findContours(morphedthresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
" biggestcontour = max(contours, key=cv2.contourArea)\n",
" \n",
" \n",
" # epsilon = 0.0005*cv2.arcLength(biggestcontour,True)\n",
" # approx = cv2.approxPolyDP(biggestcontour,epsilon,True)\n",
" \n",
" blank = np.full(thresh.shape, 255, dtype=np.uint8)\n",
" mask1 = 255 - blank.copy()\n",
" mask1 = cv2.drawContours(mask1, [biggestcontour], -1, 255, thickness=cv2.FILLED)\n",
" \n",
" mask1 = mf.padWithColour(mask1, sdim, sdim, fill=0)\n",
" \n",
" mask1 = cv2.morphologyEx(mask1, cv2.MORPH_CLOSE, skernel)\n",
" mask1 = cv2.morphologyEx(mask1, cv2.MORPH_OPEN, skernel)\n",
" # mask1 = cv2.morphologyEx(mask1, cv2.MORPH_OPEN, skernel)\n",
" # return mask1\n",
" \n",
" \n",
" mask1contours, heirarchy = cv2.findContours(mask1, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
" \n",
" biggestm1contour = max(mask1contours, key=cv2.contourArea)\n",
" \n",
" mask1_1 = 255-blank.copy()\n",
" mask1_1 = mf.padWithColour(mask1_1, sdim, sdim, fill=0)\n",
" mask1_1 = cv2.drawContours(mask1_1, [biggestm1contour], -1, 255, thickness=cv2.FILLED)\n",
" mask1_1 = 255-mask1_1\n",
" \n",
" dim = max(2,int(min(image.shape[0], image.shape[1])/100))\n",
" # print(dim)\n",
" kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (dim, dim))\n",
" mask1_1 = cv2.morphologyEx(mask1_1, cv2.MORPH_DILATE, kernel, iterations=1)\n",
" mask1_1 = mask1_1[sdim:-sdim, sdim:-sdim]\n",
" \n",
" # epsilon = 0.01*cv2.arcLength(biggestm1contour,True)\n",
" # approxm1 = cv2.approxPolyDP(biggestm1contour,epsilon,True)\n",
" \n",
" # hull = cv2.convexHull(biggestcontour)\n",
" # hull = cv2.convexHull(approx)\n",
" # mask2 = 255 - blank.copy()\n",
" # mask2 = cv2.drawContours(mask2, [hull], -1, 255, thickness=cv2.FILLED)\n",
" \n",
" # imagecpy = cv2.drawContours(imagecpy, [biggestcontour], -1, (255,0,0), thickness=3)\n",
" # # imagecpy = cv2.drawContours(imagecpy, [approx], -1, (0,255,0), thickness=3)\n",
" # # imagecpy = cv2.drawContours(imagecpy, [hull], -1, (0,255,255), thickness=3)\n",
" # imagecpy = cv2.drawContours(imagecpy, [biggestm1contour], -1, (0,0,255), thickness=3)\n",
" # # imagecpy = cv2.drawContours(imagecpy, [approxm1], -1, (255,0,255), thickness=3)\n",
" # return imagecpy\n",
" \n",
" # mask = 255 - cv2.bitwise_and(mask1, mask2)\n",
" # return mask1_1\n",
" \n",
" maskc = cv2.cvtColor(mask1_1, cv2.COLOR_GRAY2BGR)\n",
" # return maskc\n",
" # return blurimage\n",
" # print(blurimage)\n",
" # print(maskc)\n",
" whitedbackground = cv2.bitwise_or(image, maskc)\n",
" return whitedbackground\n",
"\n",
"\n",
"\n",
"\n",
"##### NEED TO FIX THE CURVE OF CONNECTING TO THE EDGES DUE TO THE ELLIPSE KERNEL\n",
" \n",
" graywhitedbackground = cv2.cvtColor(whitedbackground, cv2.COLOR_BGR2GRAY)\n",
" # thresh2 = cv2.threshold(graywhitedbackground, 0, 255, cv2.THRESH_OTSU)[1]\n",
" blurredgraywhitedbackground = cv2.blur(graywhitedbackground, (11,11))\n",
" # blurredgraywhitedbackground = graywhitedbackground\n",
" window = blurredgraywhitedbackground.shape[1]//15\n",
" if window % 2 == 0:\n",
" window += 1\n",
" thresh2 = cv2.adaptiveThreshold(blurredgraywhitedbackground, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, window, 2)\n",
" # return thresh2\n",
" \n",
" paddedthresh2 = mf.padWithColour(thresh2, sdim, sdim, fill=255)\n",
" \n",
" \n",
" dim = max(2,int(min(image.shape[0], image.shape[1])/50))\n",
" kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (dim, dim))\n",
" t2morph = cv2.morphologyEx(paddedthresh2, cv2.MORPH_OPEN, kernel, iterations=2)\n",
" dim = int(window*1.5)\n",
" kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (dim, dim))\n",
" t2morph = cv2.morphologyEx(t2morph, cv2.MORPH_CLOSE, kernel, iterations=1)\n",
" \n",
" t2morph = t2morph[sdim:-sdim, sdim:-sdim]\n",
" # return t2morph\n",
"\n",
" # print(mask1_1.shape)\n",
" # print(t2morph.shape)\n",
" mask2 = 255-cv2.bitwise_or(mask1_1, 255-t2morph)\n",
" # return mask2\n",
" \n",
" \n",
" \n",
" mask2contours, heirarchy = cv2.findContours(mask2, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
" \n",
" biggestm2contour = max(mask2contours, key=cv2.contourArea)\n",
" \n",
" mask2_1 = 255 - blank.copy()\n",
" mask2_1 = cv2.drawContours(mask2_1, [biggestm2contour], -1, 255, thickness=cv2.FILLED)\n",
" \n",
" # return mask2_1\n",
" \n",
" mask2_1 = mf.padWithColour(mask2_1, sdim, sdim, fill=0)\n",
" \n",
" mask2_2 = cv2.morphologyEx(mask2_1, cv2.MORPH_OPEN, kernel)\n",
" \n",
" mask2_2 = 255-mask2_2[sdim:-sdim, sdim:-sdim]\n",
" \n",
" # return mask2_2\n",
"\n",
" mask2c = cv2.cvtColor(mask2_2, cv2.COLOR_GRAY2BGR)\n",
" # return maskc\n",
" # return blurimage\n",
" # print(blurimage)\n",
" # print(maskc)\n",
" whitedbackground2 = cv2.bitwise_or(image, mask2c)\n",
" return whitedbackground2\n",
" \n",
" \n",
" \n",
" \n",
" canny = cv2.Canny(graywhitedbackground, 0, 500)\n",
" return canny\n",
" \n",
" \n",
" \n",
" \n",
" \n",
" \n",
" \n",
" contours1, heirarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
" contours2, heirarchy = cv2.findContours(morphedthresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n",
@ -199,7 +469,7 @@
},
{
"cell_type": "code",
"execution_count": 26,
"execution_count": 3039,
"metadata": {},
"outputs": [],
"source": [
@ -219,107 +489,17 @@
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [],
"source": [
"def contourcrop(baseimage):\n",
" shrunkencbi, sizemultiplier = mf.ResizeWithAspectRatio(baseimage, width=1000, retscale=True)\n",
" gray = cv2.cvtColor(shrunkencbi, cv2.COLOR_BGR2GRAY)\n",
" # thresh = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY)[1]\n",
" thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_TRIANGLE)[1]\n",
" # window = gray.shape[1]//7\n",
" # if window % 2 == 0:\n",
" # window += 1\n",
" # thresh = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, window, 10)\n",
"\n",
" kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5,5))\n",
" # thresh = cv2.morphologyEx(thresh, cv2.MORPH_ERODE, kernel, iterations=2)\n",
" thresh = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)\n",
" # return thresh\n",
" \n",
" contours, heirarchy = cv2.findContours(thresh,cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)\n",
" \n",
" # temp = cv2.drawContours(shrunkencbi, contours, -1, (0,255,0), thickness=3)\n",
" # biggestcontour = max(contours, key=cv2.contourArea)\n",
" # temp = cv2.drawContours(shrunkencbi, [biggestcontour], -1, (0,255,0), thickness=3)\n",
" \n",
" # return temp\n",
" \n",
" mx = (0,0,0,0)\n",
" mx_area = 0\n",
"\n",
" for i, cont in enumerate(contours):\n",
" rect = cv2.boundingRect(cont)\n",
" area = mf.rectArea(rect)\n",
" if (area > mx_area):\n",
" mx = rect\n",
" mx_area = area\n",
"\n",
" \n",
" scaledmx = (int(mx[0]*sizemultiplier), int(mx[1]*sizemultiplier), int(mx[2]*sizemultiplier), int(mx[3]*sizemultiplier))\n",
" finalbaseimage = baseimage[scaledmx[1]:scaledmx[1]+scaledmx[3], scaledmx[0]:scaledmx[0]+scaledmx[2], :]\n",
" return finalbaseimage"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
"def houghlinedeskewthencrop(baseimage, preppedimage, rotationangle):\n",
" rotateddst1 = mf.rotatewithexactpadding(preppedimage, rotationangle, fill=0)\n",
" rotatedbaseimage = mf.rotatewithexactpadding(baseimage, rotationangle, fill=(0,0,0))\n",
" sizemultiplier = rotatedbaseimage.shape[0]/rotateddst1.shape[0]\n",
" # print(sizemultiplier)\n",
" # return rotatedbaseimage, rotationangle\n",
"\n",
" croppedbaseimage = mf.houghlinepcrop(rotatedbaseimage, rotateddst1, sizemultiplier)\n",
" # return croppedbaseimage, rotationangle\n",
"\n",
" finalbaseimage = contourcrop(croppedbaseimage)\n",
"\n",
"\n",
" return finalbaseimage, rotationangle"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [],
"source": [
"def houghlinedeskewandcrop(image):\n",
" canny, croppedogimage = mf.prepimageforhoughline(image) ## scaling and cropping occurs. need to also return the changes done\n",
" # return croppedogimage, canny\n",
" # print(canny.shape)\n",
" # print(croppedogimage.shape)\n",
"\n",
" ## -----------------finding angle to deskew-----------------\n",
" rotationangle = mf.houghlinedeskewangle(canny)\n",
" # print(rotationangle)\n",
"\n",
" # -----------------end of finding angle to deskew-----------------\n",
"\n",
" ## -----------------deskewing and then cropping-----------------\n",
" outimg, angle = houghlinedeskewthencrop(croppedogimage, canny, rotationangle)\n",
" return outimg, angle"
]
},
{
"cell_type": "code",
"execution_count": 30,
"execution_count": 3040,
"metadata": {},
"outputs": [],
"source": [
"def houghlineprocessing(image):\n",
" croppedanddeskewed, angle = houghlinedeskewandcrop(image)\n",
" return croppedanddeskewed\n",
" croppedanddeskewed, angle = mf.houghlinedeskewandcrop(image)\n",
" # return croppedanddeskewed\n",
" \n",
" \n",
" postprocessed = cropclarifying(croppedanddeskewed)\n",
" # return postprocessed\n",
" return postprocessed\n",
" postprocessed = mf.croptoblack(postprocessed)\n",
" \n",
" # postprocessed = cv2.cvtColor(postprocessed, cv2.COLOR_GRAY2BGR)\n",
@ -340,7 +520,7 @@
},
{
"cell_type": "code",
"execution_count": 31,
"execution_count": 3041,
"metadata": {},
"outputs": [],
"source": [
@ -355,7 +535,7 @@
},
{
"cell_type": "code",
"execution_count": 32,
"execution_count": 3042,
"metadata": {},
"outputs": [],
"source": [
@ -369,7 +549,7 @@
},
{
"cell_type": "code",
"execution_count": 33,
"execution_count": 3043,
"metadata": {},
"outputs": [],
"source": [
@ -381,16 +561,26 @@
},
{
"cell_type": "code",
"execution_count": 34,
"execution_count": 3044,
"metadata": {},
"outputs": [],
"source": [
"# showimgs(outs)"
"testall = True"
]
},
{
"cell_type": "code",
"execution_count": 35,
"execution_count": 3045,
"metadata": {},
"outputs": [],
"source": [
"if not testall:\n",
" showimgs(outs)"
]
},
{
"cell_type": "code",
"execution_count": 3046,
"metadata": {},
"outputs": [],
"source": [
@ -420,29 +610,49 @@
},
{
"cell_type": "code",
"execution_count": 36,
"execution_count": 3047,
"metadata": {},
"outputs": [],
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"average time: 8.021544203162193(s)\n"
]
}
],
"source": [
"results = testondataset(\"/mnt/dataset/baseimages/\", houghlineprocessing)"
"if testall:\n",
" results = testondataset(\"/mnt/dataset/baseimages/\", houghlineprocessing)"
]
},
{
"cell_type": "code",
"execution_count": 37,
"execution_count": 3048,
"metadata": {},
"outputs": [],
"source": [
"# showimgs(results)"
"# if testall:\n",
"# showimgs(results)"
]
},
{
"cell_type": "code",
"execution_count": 38,
"execution_count": 3049,
"metadata": {},
"outputs": [],
"source": [
"writeimgs(\"/mnt/code/autocropper/result_images/\", results)"
"# print(results[0])"
]
},
{
"cell_type": "code",
"execution_count": 3050,
"metadata": {},
"outputs": [],
"source": [
"if testall:\n",
" writeimgs(\"/mnt/code/autocropper/result_images/\", results)"
]
}
],

6
code/autocropper/myfunctions.py
View File

@ -439,7 +439,7 @@ def houghlinepcrop(baseimage, preppedimage, scalingmultiplier):
return croppedbaseimage
def contourcrop(baseimage):
shrunkencbi, sizemultiplier = mf.ResizeWithAspectRatio(baseimage, width=1000, retscale=True)
shrunkencbi, sizemultiplier = ResizeWithAspectRatio(baseimage, width=1000, retscale=True)
gray = cv2.cvtColor(shrunkencbi, cv2.COLOR_BGR2GRAY)
# thresh = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY)[1]
thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_TRIANGLE)[1]
@ -466,7 +466,7 @@ def contourcrop(baseimage):
for i, cont in enumerate(contours):
rect = cv2.boundingRect(cont)
area = mf.rectArea(rect)
area = rectArea(rect)
if (area > mx_area):
mx = rect
mx_area = area
@ -749,7 +749,7 @@ def textClarifying(image):
autothreshold = np.clip(np.mean(gray)/1.2, 0, 255)
lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
hls = cv2.cvtColor(image, cv2.COLOR_BGR2HLS)
# hls = cv2.cvtColor(image, cv2.COLOR_BGR2HLS)
kernel1 = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
kernel2 = cv2.getStructuringElement(cv2.MORPH_RECT, (4, 4))