def createMarkers(
): #run this program then print the markers that are saved in this program's directory
aruco_dict = aruco.Dictionary_get(
aruco.DICT_6X6_250) #set aruco dictionary
Mk1 = aruco.drawMarker(aruco_dict, 1, 700) #creat marker with ID1 size 700
Mk2 = aruco.drawMarker(aruco_dict, 2, 700) #creat marker with ID2 size 700
cv2.imwrite('marker1.jpg', Mk1) #save markers
cv2.imwrite('marker2.jpg', Mk2)
cv2.imshow('Marker 1', Mk1) #show markers
cv2.imshow('Marker 2', Mk2)
cv2.waitKey(0)
cv2.destroyAllWindows()
def create_markers():
j=2
markers_dict_1 = aruco.getPredefinedDictionary(aruco.DICT_6X6_50)
markers_dict1= custom_dictionary_from(j,6,markers_dict_1)
markers_dict_2 = aruco.getPredefinedDictionary(aruco.DICT_7X7_50)
markers_dict2 = custom_dictionary_from(j,7,markers_dict_2)
markers1 = list(aruco.drawMarker(markers_dict1,i+1,200) for i in range(1))
markers2 = list(aruco.drawMarker(markers_dict2,i+1,200) for i in range(1))
for i in range(len(markers1)):
cv2.imwrite(os.path.join('markers','marker6_')+str(i+1) + '.png',markers1[i])
for i in range(len(markers2)):
cv2.imwrite(os.path.join('markers','marker7_')+str(i+1)+'.png', markers2[i])
return markers_dict1, markers_dict2
def aruco_gen(id_aruco, num_pixels):
aruco_dict = aruco.Dictionary_get(aruco.DICT_4X4_1000) #replace n with no. of bits per pixel and C with the no. of combinations
#select n and C from the list mentioned above
img = cv2.cvtColor(aruco.drawMarker(aruco_dict, id_aruco, num_pixels),cv2.COLOR_GRAY2RGB)
img_border=cv2.copyMakeBorder(img,25,25,25,25,cv2.BORDER_CONSTANT,value=[255,255,255])
text="ArUco ID = "+str(id_aruco)
textsize = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)[0]
textX = int((img.shape[1] - textsize[0]) / 2)
textY = int(( textsize[1]+12) / 2)
cv2.putText(img_border,text, (textX,textY), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,0,255))
path=""
cv2.imwrite(path+("ArUco"+str(id_aruco)+".jpg"),img_border)
path="Images/"
cv2.imwrite(path+("ArUco"+str(id_aruco)+".jpg"),img_border)
cv2.imshow('frame',img_border)
cv2.waitKey(0)
'''
code here for saving the Aruco image as a "jpg" by following the steps below:
1. save the image as a colour RGB image in OpenCV color image format
2. embed a boundary of 25 pixels on all four sides and three channels of the image
3. save the image as "ArUcoID.jpg" where ID is the digits of id_aruco i.e. if the ID is 26 the name should be: ArUco26.jpg
4. APIs which are permitted to be used are:
a. cvtColor
b. imwrite
and other OpenCV APIs.
5. You are permitted to modify n, C and variables id_aruco and num_pixels
'''
cv2.destroyAllWindows()
def create_aruco():
"""create four arucos on A4"""
aruco_dict = aruco.Dictionary_get(aruco.DICT_4X4_50)
parameters = aruco.DetectorParameters_create()
img = np.ones((A4_PIX_H, A4_PIX_W, 3), dtype=np.uint8) * 255
img_h, img_w, channel = img.shape
for i in range(4):
aruco_marker = aruco.drawMarker(aruco_dict, i, aruco_size)
aruco_marker = cv2.cvtColor(aruco_marker, cv2.COLOR_GRAY2BGR)
if i == 0:
img[pad:pad + aruco_size, pad:pad + aruco_size] = aruco_marker
elif i == 1:
img[pad:pad + aruco_size,
img_w - pad - aruco_size:img_w - pad] = aruco_marker
elif i == 2:
img[img_h - pad - aruco_size:img_h - pad,
img_w - pad - aruco_size:img_w - pad] = aruco_marker
else:
img[img_h - pad - aruco_size:img_h - pad,
pad:pad + aruco_size] = aruco_marker
cv2.imwrite('../result.jpg', img)
corners, ids, rejectedImgs = aruco.detectMarkers(img,
aruco_dict,
parameters=parameters)
print(corners)
print(ids)
grayscale = aruco.drawDetectedMarkers(img, corners, ids, (0, 0, 255))
cv2.imshow('frame', grayscale)
cv2.imwrite("../detect_result.jpg", grayscale)
cv2.waitKey(0)
cv2.destroyAllWindows()
return img
def aruco_gen(
id_aruco, num_pixels
): #This function expects two parameters as arguments-ID and the number of pixels in resolution. Both these inputs are whole decimal numbers.
aruco_dict = aruco.Dictionary_get(
aruco.DICT_nXn_C
) #Replace n with number of bits per pixels and C with the number of combinations
img = aruco.drawMarker(
aruco_dict, id_aruco,
num_pixels) #Select n and C from the list mentioned above
img1 = cv2.copyMakeBorder(
img, 25, 25, 25, 25, cv2.BORDER_CONSTANT,
value=255) #embeds a white border of 25 pixels on all sides
image = cv2.cvtColor(img1, cv2.COLOR_GRAY2BGR) #RGB color conversion
font = cv2.FONT_HERSHEY_SIMPLEX
s1 = 'ArUco ID='
s2 = str(id_aruco)
sf = s1 + s2
cv2.putText(image, sf, (180, 15), font, 0.50, (0, 0, 255),
1) #embeds the ID of the ArUco marker in Red Font
des1 = 'C:\\400_Task1.1\\Images\\ArUco'
des2 = '.jpg'
destination = des1 + s2 + des2
cv2.imwrite(
destination,
image) #saves the image as ArUco<#ID>.jpg as per the respective ID
cv2.imshow('frame', image)
cv2.waitKey(0)
cv2.destroyAllWindows()
def marcador():
cod = request.args.get('cod')
img_marcador = aruco.drawMarker(dictionary, int(cod) - 1, 600)
cv2.imwrite(os.path.join('static', 'markers', '{}.png'.format(cod)), img_marcador)
html = render_template('marcador.html', cod=int(cod))
Timer(60, delete_image, (cod,)).start()
return html
def generate_marker(marker_code,
aruco_dict=aruco.DICT_5X5_250,
size=200,
filename="img.png"):
ardict = aruco.getPredefinedDictionary(aruco_dict)
img = aruco.drawMarker(ardict, marker_code, size)
print(cv2.imwrite(filename, img))
def generate_markers(kind='target'):
'''
generate all markers for a given kind
Parameters
----------
kind : string, mandatory
either 'target, 'obstacle', 'other'. The default is 'target'.
Returns
-------
None.
'''
range_ = MARKER_TARGET_RANGE if kind == 'target' \
else MARKER_OBSTACLE_RANGE if kind == 'obstacle' \
else MARKER_OTHER
margin = 50
base = np.ones((200 + 2 * margin, 200 + 2 * margin), dtype=np.uint8) * 255
#build the markers and save them to disk
for idx in range_:
curr_marker = aruco.drawMarker(dictionary=DICT_44_250,
id=idx,
sidePixels=200,
borderBits=2)
curr = base.copy()
curr[margin:200 + margin, margin:200 + margin] = curr_marker
cv2.imwrite(f'../data/markers/marker_{idx}.png', curr)
def create_aruco_marker(self,
id: int = 1,
resolution: int = 50,
show: bool = False,
save: bool = False,
path: str = './'):
""" Function that creates a single aruco marker providing its id and resolution
Args:
id: int indicating the id of the aruco to create
resolution: int
show: boolean. Display the created aruco marker
save: boolean. save the created aruco marker as an image "Aruco_Markers.jpg"
path: path to where the aruco will be saved. If none specified will be saved in the same direcory of execution the code
Returns:
ArucoImage: numpy array with the aruco information
"""
self.ArucoImage = 0
aruco_dictionary = aruco.Dictionary_get(self.aruco_dict)
img = aruco.drawMarker(aruco_dictionary, id, resolution)
fig, ax = plt.subplots()
ax.imshow(img, cmap=plt.cm.gray, interpolation="nearest")
ax.axis("off")
if show is True:
fig.show()
else:
plt.close(fig)
if save is True:
fig.savefig(path + "Aruco_Markers.png")
self.ArucoImage = img
return self.ArucoImage
def aruco_gen(id_aruco, num_pixels):
aruco_dict = aruco.Dictionary_get(aruco.DICT_4X4_50)
img = aruco.drawMarker(aruco_dict, id_aruco, num_pixels)
dst = cv2.copyMakeBorder(img,
25,
25,
25,
25,
cv2.BORDER_CONSTANT,
value=[255, 0, 0])
img1 = cv2.cvtColor(dst, cv2.COLOR_GRAY2BGR)
img1 = cv2.putText(img1, 'ArUco ID = 2', (120, 21),
cv2.FONT_HERSHEY_SIMPLEX, 0.9, (255, 0, 0), 2)
img1 = img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB)
cv2.imshow('frame', img1)
cv2.imwrite('Aruco2.jpeg', img1)
cv2.waitKey(0)
cv2.destroyAllWindows()
def create_arucos_pdf(self,
nx: int = 5,
ny: int = 5,
resolution: int = 50,
path: str = './'):
"""
FUnction to create a pdf file with nx X ny number of arucos and save them in specified path
Args:
nx: number of rows
ny: number of columns
resolution: resolution of the image (arucos)
path: path to where the aruco will be saved. If none specified will be saved in the same direcory of execution the code
Returns:
image of the arucos and the saved pdf
"""
aruco_dictionary = aruco.Dictionary_get(self.aruco_dict)
fig = plt.figure()
for i in range(1, nx * ny + 1):
ax = fig.add_subplot(ny, nx, i)
img = aruco.drawMarker(aruco_dictionary, i, resolution)
plt.imshow(img, cmap='gray')
plt.imshow(img, cmap='gray')
ax.axis("off")
fig.savefig(path + "markers.pdf")
fig.show()
return fig
def aruco_gen(id_aruco, num_pixels):
aruco_dict = aruco.Dictionary_get(
aruco.DICT_5X5_250
) # aruco.DICT_nXn_C , replace n with no. of bits per pixel and C with the no. of combinations
WHITE = [255, 255, 255] #select n and C from the list mentioned above
font = cv2.FONT_HERSHEY_SIMPLEX
img = aruco.drawMarker(aruco_dict, id_aruco, num_pixels)
constant = cv2.copyMakeBorder(img,
25,
25,
25,
25,
cv2.BORDER_CONSTANT,
value=WHITE)
i = cv2.putText(
constant,
'ArUco ID = ' + str(id_aruco),
(155, 15),
font,
0.5,
(0, 0, 255),
2,
)
cv2.imshow('ArUco', i)
cv2.imwrite('ArUco' + str(id_aruco) + '.jpg', i)
cv2.waitKey(0)
'''
code here for saving the Aruco image as a "jpg" by following the steps below:
1. save the image as a colour RGB image in OpenCV color image format
2. embed a boundary of 25 pixels on all four sides and three channels of the image
3. save the image as "ArUcoID.jpg" where ID is the digits of id_aruco i.e. if the ID is 26 the name should be: ArUco26.jpg
4. You are permitted to modify n, C and variables id_aruco and num_pixels
'''
cv2.destroyAllWindows()
def create_marker(marker_number):
aruco_dict = aruco.Dictionary_get(aruco.DICT_6X6_250)
#print(aruco_dict)
img = aruco.drawMarker(aruco_dict, marker_number, 700)
cv2.imwrite("marker" + str(marker_number) + ".jpg", img)
cv2.imshow('frame', img)
cv2.waitKey(0)
def create_marker(ident=2):
aruco_dict = aruco.Dictionary_get(aruco.DICT_6X6_250)
print(aruco_dict)
# second parameter is id number
# last parameter is total image size
img = aruco.drawMarker(aruco_dict, ident, 700)
cv2.imwrite("test_marker%d.jpg" % ident, img)
def aruco_gene(aruco_dict, iterations, sidepixels):
'''
aruco_gene(...)
aruco_gene(dictionary, Iterations(ids),
sidePixels[, img[, borderBits]]) -> img
'''
for i in range(iterations):
img1 = aruco.drawMarker(aruco_dict, i, sidepixels)
cv2.imwrite("{}.jpg".format(i), img1)
def __init__(self, idi: int, size: int = 700, bgsize: int = 1):
self._id = idi
self._dic = cv2.aruco.Dictionary_get(cv2.aruco.DICT_6X6_250)
img = np.zeros((size, size), dtype=np.uint8)
self._img = aruco.drawMarker(self._dic,
idi,
size,
img,
borderBits=bgsize)
def generate_blob():
ar_dict = ar.Dictionary_get(ar.DICT_6X6_250)
img = ar.drawMarker(ar_dict, 2, 700)
cv2.imwrite('test_marker.jpg', img)
cv2.imshow('frame', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
def createArucoMarkers():
outputMarker = []
markerDictionary = aruco.getPredefinedDictionary(aruco.DICT_4X4_50)
for i in range(50):
outputMarker = aruco.drawMarker(markerDictionary, i, 500)
imageName = "4x4Marker_" + str(i) + ".jpg"
#f=open(imageName,"w")
cv2.imwrite(imageName, outputMarker)
def drawMarkerAt(id, markerCenter):
marker = aruco.drawMarker(aruco_dict, id, markerPx*2, borderBits=1)
paddedMarker = np.ones((facePx*2, facePx*2))*255
padding = facePx-markerPx
paddedMarker[padding:(facePx*2)-padding,
padding:(facePx*2)-padding] = marker
cv2.rectangle(paddedMarker, (0,0), (paddedMarker.shape[0]-1, paddedMarker.shape[1]-1), 0, 1)
cubeTemplate[markerCenter[1] - facePx:markerCenter[1] + facePx,
markerCenter[0] - facePx:markerCenter[0] + facePx] = paddedMarker
def genMarker(i, dicno, paper_size):
print " Marker %d\r" % i,
sys.stdout.flush()
aruco_dict = aruco.Dictionary_get(dicno)
img = aruco.drawMarker(aruco_dict, i, 2000)
cv2.imwrite("/tmp/marker%d.png" % i, img)
svg = genSvg(i, dicno, paper_size)
cairosvg.svg2pdf(bytestring=svg, write_to='/tmp/marker%d.pdf' % i)
os.remove("/tmp/marker%d.png" % i)
def generateMarker(self, ID=7, size=700):
# Create an image from the marker
img = aruco.drawMarker(self.arucoDict, ID, size)
# Save and display (press any key to exit)
cv2.imwrite('ARUCO_'+str(ID)+'.png', img)
cv2.imshow('Marker ID: ' + str(ID), img)
cv2.waitKey(0)
cv2.destroyAllWindows()
def main():
"""Execute the command"""
aruco_dict = aruco.Dictionary_get(aruco.DICT_6X6_250)
fig = plt.figure()
parser = argparse.ArgumentParser(
description='Create aruco fiducial markers')
parser.add_argument('-b',
'--basename',
help='basename for file (an extension is added)',
required=False,
default='marker')
parser.add_argument('-i',
'--id',
type=int,
help='marker ID',
required=False,
default=1)
parser.add_argument('-p',
'--pair',
help='create a pair of markers',
required=False,
action='store_true')
args = parser.parse_args()
if not args.pair:
img = aruco.drawMarker(aruco_dict, args.id, 700)
filename = args.basename + '.png'
cv2.imwrite(filename, img)
print('Created ID %d marker into file %s' % (args.id, filename))
else:
ax = fig.add_subplot(1, 4, 1)
img = aruco.drawMarker(aruco_dict, args.id, 700)
plt.imshow(img, cmap=mpl.cm.gray, interpolation='nearest')
ax.axis('off')
ax = fig.add_subplot(1, 4, 4)
img = aruco.drawMarker(aruco_dict, args.id, 700)
plt.imshow(img, cmap=mpl.cm.gray, interpolation='nearest')
ax.axis('off')
filename = args.basename + '.pdf'
plt.savefig(filename)
print('Created pair of ID %d markers into file %s' %
(args.id, filename))
def generateTag(dir, id):
''' The actual tag generator '''
aruco_dict = aruco.Dictionary_get(aruco.DICT_6X6_250)
img = aruco.drawMarker(aruco_dict, id, 700)
write_dir = dir + "/../tags/" + str(id) + ".jpg"
print("Writing to: " + write_dir)
cv2.imwrite(write_dir, img)
return img
def main():
count = 100
size = 200
path = "markers/4x4"
os.makedirs(path, exist_ok=True)
aruco_dict = aruco.Dictionary_get(aruco.DICT_4X4_250)
for i in range(0, count):
image = aruco.drawMarker(aruco_dict, i, size)
cv.imwrite("{}/{:02d}.png".format(path, i), image)
def makearucoboard(nrow,
ncolumn,
markerdict=aruco.DICT_6X6_250,
markersize=25,
savepath='./',
paperwidth=210,
paperheight=297,
dpi=600):
"""
create aruco board
the paper is in portrait orientation, nrow means the number of markers in the vertical direction
:param nrow:
:param ncolumn:
:param markerdict:
:param markersize:
:param savepath:
:param paperwidth: mm
:param paperheight: mm
:param dpi:
:return:
author: weiwei
date: 20190420
"""
aruco_dict = aruco.Dictionary_get(markerdict)
# 1mm = 0.0393701inch
a4npxrow = int(paperheight * 0.0393701 * dpi)
a4npxcolumn = int(paperwidth * 0.0393701 * dpi)
bgimg = np.ones((a4npxrow, a4npxcolumn), dtype='uint8') * 255
markersizepx = int(markersize * 0.0393701 * dpi)
markerdist = int(markersizepx / 4)
markerareanpxrow = (nrow - 1) * (markerdist) + nrow * markersizepx
uppermargin = int((a4npxrow - markerareanpxrow) / 2)
markerareanpxcolumn = (ncolumn - 1) * (markerdist) + ncolumn * markersizepx
leftmargin = int((a4npxcolumn - markerareanpxcolumn) / 2)
if (uppermargin <= 10) or (leftmargin <= 10):
print("Too many markers! Reduce nrow and ncolumn.")
return
for idnr in range(nrow):
for idnc in range(ncolumn):
startrow = uppermargin + idnr * (markersizepx + markerdist)
endrow = startrow + markersizepx
startcolumn = leftmargin + idnc * (markersizepx + markerdist)
endcolumn = markersizepx + startcolumn
i = (idnr + 1) * (idnc + 1)
img = aruco.drawMarker(aruco_dict, i, markersizepx)
bgimg[startrow:endrow, startcolumn:endcolumn] = img
im = Image.fromarray(bgimg).convert("L")
im.save(savepath + "test.pdf", "PDF", resolution=dpi)
def generate_tag():
aruco_dict = aruco.Dictionary_get(aruco.DICT_6X6_250)
print(aruco_dict)
# second parameter is id number
# last parameter is total image size
img = aruco.drawMarker(aruco_dict, 4, 700)
cv2.imwrite("test_marker4.jpg", img)
cv2.imshow('frame', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
def show_aruco(self):
aruco_dict = aruco.getPredefinedDictionary(aruco.DICT_4X4_250)
image = aruco.drawMarker(aruco_dict, 3, 700)
photo = ImageTk.PhotoImage(image=PIL.Image.fromarray(image))
self.projector_window.canvas.create_image(500, 400, image=photo)
return np.array(
[[150, 50, 0], [850, 50, 0], [850, 750, 0], [150, 750, 0]],
dtype=np.float32)
def create_marker(size, id, margin):
aruco_dict = aruco.Dictionary_get(aruco.DICT_6X6_250)
# white background
img = 255 * np.ones((size, size), dtype=np.uint8)
img_marker = aruco.drawMarker(aruco_dict, id, size - 2 * margin)
# add marker centered
img[margin:-margin, margin:-margin] = img_marker
return img
def gen_aruco(n):
while(n):
img = np.zeros((100,100,3), np.uint8)
Dictionary = aruco.getPredefinedDictionary(aruco.DICT_ARUCO_ORIGINAL)
img=aruco.drawMarker(Dictionary,n,100,img,1)
#cv2.imwrite('C:\\Users\\ailab\\PycharmProjects\\drone\\train\\'+str(n)+'.jpg',img)
cv2.imwrite('C:\\Users\\ailab\\PycharmProjects\\drone\\train\\class_0\\' + 'aruco_0_'+str(n) + '.jpg', img)
print('gen_aruco: '+'aruco_0_'+str(n) + '.jpg')
n = n - 1
return 0
def generateMarkers():
aruco_dict = aruco.Dictionary_get(aruco.DICT_6X6_250)
print(aruco_dict)
# second parameter is id number
# last parameter is total image size
img = aruco.drawMarker(aruco_dict, 2, 700)
cv2.imwrite("../Samples/Pictures/Markers/marker.jpg", img)
cv2.imshow('frame', img)
cv2.waitKey(0)
cv2.destroyAllWindows()
if error:
displayHelp()
quit()
pdf = canvas.Canvas(outputfile, pagesize=letter)
pagepos = 0
cardcount = 0
# Prepare the marker dictionary.
aruco_dict = aruco.Dictionary_get(aruco.DICT_4X4_50)
markersize = 60
for cn in range(cnstart, cnend+1):
marker = cv2.cvtColor(aruco.drawMarker(aruco_dict, cn, markersize), cv2.COLOR_GRAY2BGR)
marker = cv2.copyMakeBorder(marker, 10, 10, 10, 10, cv2.BORDER_CONSTANT, value=[255,255,255])
cv2.imwrite(imgfile, marker)
# Trim the image file down.
# There seems to be a bug in reportlab.
# Strings are drawn in the A4 template even though we've set the pagesize to letter.
# Do text positioning based on A4.
if pagepos == 0:
pos = margin*inch, margin*inch
elif pagepos == 1:
pos = (margin+cwidth)*inch, margin*inch
elif pagepos == 2:
pos = (margin+cwidth*2)*inch, margin*inch
#!/usr/bin/env python2
#encoding: UTF-8
import cv2
import cv2.aruco as aruco
if __name__ == "__main__":
print "AR Figure"
aruco_dict = aruco.Dictionary_get(aruco.DICT_4X4_100)
markersize = 22
blackborder = 1
whiteborder = 1
for markerid in range(0, 100):
marker = cv2.cvtColor(aruco.drawMarker(aruco_dict, markerid, markersize,borderBits=blackborder), cv2.COLOR_GRAY2BGR) #borderBits
if whiteborder > 0:
marker = cv2.copyMakeBorder(marker, whiteborder, whiteborder, whiteborder, whiteborder, cv2.BORDER_CONSTANT, value=[255,255,255])
imagefile = "images/4X4_" + str(markerid)+".png"
cv2.imwrite(imagefile, marker)
print "wrote: " + imagefile
