def main():
os.chdir(os.path.join(sys.argv[1], "motion"))
try:
os.mkdir(OUTPUT_DIR_NAME)
except OSError:
pass
#os.system("del klein\\*.png")
os.system("convert motion_*.png -adaptive-resize 500x500! " +
OUTPUT_DIR_NAME + "\\motion_%02d.png")
os.chdir(OUTPUT_DIR_NAME)
os.system("convert motion_*.png -append result.png")
img = cv.LoadImageM("result.png")
values = []
for y in range(img.rows):
value = cv.Get1D(cv.GetRow(img, y), 0)[0]
values.append(value)
values.sort(reverse=True)
output_img = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_8U, 3)
for y in range(img.rows):
for x in range(img.cols):
cv.Set2D(output_img, y, x, cv.RGB(values[y], values[y], values[y]))
cv.SaveImage("result_sorted.png", output_img)
raw_input("- done -")
return
def main():
os.chdir(sys.argv[1])
#print "DELETE ALL FILES FIRST!"
#tree = et.parse("project.xml")
#movie = tree.getroot()
#start_frame = int( movie.attrib["start_frame"] )
#end_frame = int( movie.attrib["end_frame"] )
f_shots = open("shots.txt")
shots = [
(int(start), int(end))
for start, end in [line.split("\t")[0:2] for line in f_shots if line]
]
f_shots.close()
f_chapters = open("chapters.txt")
chapters = [int(line) for line in f_chapters if line]
f_chapters.close()
'''# fix first and add last frame
chapters[0] = start_frame
chapters.append(end_frame)'''
os.chdir("shot_colors")
try:
os.mkdir(OUTPUT_DIR_NAME)
except:
pass
filenames = glob.glob("shot_colors_*.png")
last_shot_nr = 0
ch = 1
for i, shot in enumerate(shots):
start_frame, end_frame = shot
if ch == len(chapters): # will this ever happen, freder?
print("den rest noch")
#print " ".join(filenames[last_shot_nr:])
os.system("convert %s -append chapters/chapter_%02d.png" %
(" ".join(filenames[last_shot_nr:]), ch))
break
elif end_frame >= chapters[ch]:
#if end_frame >= chapters[ch]:
print("{} : {} -> {}".format(ch, last_shot_nr, i - 1))
print(" ".join(filenames[last_shot_nr:i]))
os.system("convert %s -append chapters/chapter_%02d.png" %
(" ".join(filenames[last_shot_nr:i]), ch))
last_shot_nr = i
ch += 1
os.chdir(OUTPUT_DIR_NAME)
for file_nr, file in enumerate(os.listdir(os.getcwd())):
if os.path.isdir(file):
continue
img_orig = cv.LoadImageM(file)
w, h = img_orig.cols, img_orig.rows
img_hls = cv.CreateImage((w, h), cv.IPL_DEPTH_8U, 3)
cv.CvtColor(img_orig, img_hls, cv.CV_BGR2HLS)
output_img = cv.CreateImage((PIXELS_PER_COLOR * NUM_CLUSTERS, h),
cv.IPL_DEPTH_8U, 3)
# convert to numpy array
a = numpy.asarray(cv.GetMat(img_hls))
a = a.reshape(a.shape[0] * a.shape[1],
a.shape[2]) # make it 1-dimensional
# set initial centroids
init_cluster = []
step = w / NUM_CLUSTERS
#for x, y in [(0*step, h*0.1), (1*step, h*0.3), (2*step, h*0.5), (3*step, h*0.7), (4*step, h*0.9)]:
for x, y in [(0 * step, h * 0.1), (1 * step, h * 0.1),
(2 * step, h * 0.3), (3 * step, h * 0.3),
(4 * step, h * 0.5), (5 * step, h * 0.5),
(6 * step, h * 0.7), (7 * step, h * 0.7),
(8 * step, h * 0.9), (9 * step, h * 0.9)]:
x = int(x)
y = int(y)
init_cluster.append(a[y * w + x])
centroids, labels = scipy.cluster.vq.kmeans2(a,
numpy.array(init_cluster))
vecs, dist = scipy.cluster.vq.vq(a, centroids) # assign codes
counts, bins = scipy.histogram(vecs,
len(centroids)) # count occurrences
centroid_count = []
for i, count in enumerate(counts):
if count > 0:
centroid_count.append((centroids[i].tolist(), count))
centroid_count.sort(hls_sort2)
px_count = w * h
x = 0
for item in centroid_count:
count = item[1] * (PIXELS_PER_COLOR * NUM_CLUSTERS)
count = int(math.ceil(count / float(px_count)))
centroid = item[0]
for l in range(count):
if x + l >= PIXELS_PER_COLOR * NUM_CLUSTERS:
break
for y in range(h):
cv.Set2D(output_img, y, x + l,
(centroid[0], centroid[1], centroid[2]))
x += count
output_img_rgb = cv.CreateImage(cv.GetSize(output_img),
cv.IPL_DEPTH_8U, 3)
cv.CvtColor(output_img, output_img_rgb, cv.CV_HLS2BGR)
cv.SaveImage(file, output_img_rgb)
# save to text-file
if file_nr == 0:
f_out = open(os.path.join("..", "..", "chapter_colors.txt"), "w")
f_out.write("") # reset
f_out.close()
f_out = open(os.path.join("..", "..", "chapter_colors.txt"), "a")
row = cv.GetRow(output_img_rgb, 0)
WIDTH = row.cols
#print WIDTH
data_items = []
counter = 0
last_px = cv.Get1D(row, 0)
for i in range(WIDTH):
px = cv.Get1D(row, i)
if px == last_px:
counter += 1
if i == WIDTH - 1:
#f_out.write("%d, %d, %d, %d _ " % (int(last_px[2]), int(last_px[1]), int(last_px[0]), counter))
data_items.append(
"%d, %d, %d, %d" % (int(last_px[2]), int(
last_px[1]), int(last_px[0]), counter))
continue
else:
#f_out.write("%d, %d, %d, %d _ " % (int(last_px[2]), int(last_px[1]), int(last_px[0]), counter))
data_items.append("%d, %d, %d, %d" % (int(
last_px[2]), int(last_px[1]), int(last_px[0]), counter))
counter = 1
last_px = px
print("{} colors missing".format(NUM_CLUSTERS - len(data_items)))
for j in range(NUM_CLUSTERS -
len(data_items)): # sometimes there are fewer colors
data_items.append("0, 0, 0, 0")
f_out.write(" _ ".join(data_items))
f_out.write("\n")
f_out.close()
os.system("convert chapter_*.png -append _CHAPTERS.png")
return
# remove row name from data
for j in range(0, numRows):
data[j].pop(0)
# fill data matrix
samples = cv.fromarray(np.array(data, np.float32))
# set ten iterations of the k-means algorithm
criteria = (cv.CV_TERMCRIT_EPS + cv.CV_TERMCRIT_ITER, 10, 1.0)
# k-means algorithm (implementation in OpenCV)
cv.KMeans2(samples, clusters, labels, criteria)
# get the cluster info into an array
for j in range(0, numRows):
cluster.append(int(cv.Get1D(labels, j)[0]))
# prep output file
output = open(outFile, "wb")
writer = csv.writer(output, dialect='excel-tab')
# write the first row
firstRow.insert(1, "Cluster")
writer.writerow(firstRow)
for j in range(0, numRows):
row = rows[j]
row.insert(1, cluster[j])
writer.writerow(row)
# close output file
def main():
project_root_dir = sys.argv[1]
os.chdir(project_root_dir)
os.chdir(os.path.join(OUTPUT_DIR_NAME, OUTPUT_DIR_NAME))
output_img = cv.CreateImage((WIDTH, WIDTH), cv.IPL_DEPTH_8U, 3)
print os.system("identify -format \"%k\" result.png")
print "reducing colors to 10"
os.system("convert result.png +dither -colors 10 result_quant.png")
img_orig = cv.LoadImageM("result_quant.png")
output_img = cv.CreateImage((WIDTH, WIDTH), cv.IPL_DEPTH_8U, 3)
img_hls = cv.CreateImage(cv.GetSize(img_orig), cv.IPL_DEPTH_8U, 3)
cv.CvtColor(img_orig, img_hls, cv.CV_BGR2HLS)
pixels = numpy.asarray(cv.GetMat(img_hls))
d = {}
print "counting..."
for line in pixels:
for px in line:
if tuple(px) in d:
d[tuple(px)] += 1
else:
d[tuple(px)] = 1
colors = d.keys()
#print "%d pixels, %d colors" % (img_orig.width*img_orig.height, len(colors))
print "sorting..."
#colors.sort(hls_sort)
colors = sort_by_distance(colors)
px_count = img_orig.width * img_orig.height
x_pos = 0
print "building image..."
for color in colors:
l = d[color] / float(px_count)
l = int(math.ceil( l*WIDTH ))
for x in range(l):
if x_pos+x >= WIDTH:
break
for y in range(WIDTH):
cv.Set2D(output_img, y, x_pos+x, (int(color[0]), int(color[1]), int(color[2])))
x_pos += l
print "saving..."
output_img_rgb = cv.CreateImage(cv.GetSize(output_img), cv.IPL_DEPTH_8U, 3)
cv.CvtColor(output_img, output_img_rgb, cv.CV_HLS2BGR)
cv.SaveImage("_RESULT.png", output_img_rgb)
os.chdir( r"..\.." )
f = open("colors.txt", "w")
row = cv.GetRow(output_img_rgb, 0)
counter = 0
last_px = cv.Get1D(row, 0)
for i in range(WIDTH):
px = cv.Get1D(row, i)
if px == last_px:
counter += 1
if i == WIDTH-1:
f.write("%d, %d, %d, %d\n" % (int(last_px[2]), int(last_px[1]), int(last_px[0]), counter))
continue
else:
f.write("%d, %d, %d, %d\n" % (int(last_px[2]), int(last_px[1]), int(last_px[0]), counter))
counter = 1
last_px = px
f.close()
return
def main():
tree = utils.open_project(sys.argv)
if tree == None:
return
try:
os.mkdir(OUTPUT_DIR_NAME)
except OSError:
pass
movie = tree.getroot()
file_path = movie.attrib["path"]
cap = cv.CreateFileCapture(file_path)
cv.QueryFrame(cap)
# skip frames in the beginning, if neccessary
start_frame = int(movie.attrib["start_frame"])
for i in range(start_frame):
cv.QueryFrame(cap)
f = open("shots.txt", "r")
lines = [line for line in f if line]
f.close()
t = time.time()
w = None
h = None
#for line in f:
for nr, line in enumerate(lines):
print(nr + 1), "/", len(lines)
#frame_from, frame_to, width, scene_nr = [int(i) for i in line.split("\t")]
#width, scene_nr = [int(i) for i in line.split("\t")][2:]
start_frame, end_frame, width = [
int(splt) for splt in line.split("\t")
]
#width *= STRETCH_FAKTOR
faktor = None
output_img = None
for frame_counter in range(width):
#if frame_counter % STRETCH_FAKTOR == 0:
# img = cv.QueryFrame(cap)
# if not img:
# break
img = cv.QueryFrame(cap)
if not img:
break
if nr == 0:
w = img.width
h = img.height
if frame_counter == 0:
faktor = float(w) / float(width)
output_img = cv.CreateImage((width, h), cv.IPL_DEPTH_8U, 3)
col_nr = faktor * (frame_counter + 0.5)
col_nr = int(math.floor(col_nr))
#print frame_counter, width, col_nr, w
col = cv.GetCol(img, col_nr)
for i in range(h):
cv.Set2D(output_img, i, frame_counter, cv.Get1D(col, i))
#return
cv.SaveImage(
os.path.join(OUTPUT_DIR_NAME,
"shot_slitscan_%03d_%d.png" % (nr + 1, start_frame)),
output_img)
print "%.2f min" % ((time.time() - t) / 60)
#raw_input("- done -")
return
#Cargo la imagen (argv[1]) y le aplico el filtro de escala de grises
storage = cv.CreateMat(1, 8, cv.CV_32FC3)
#Creo la matriz en la que voy a meter los posibles circulos que sean encontrados en la imagen
#Si el numero de circulos es mayor que 8, el programa ya no funciona, deben de ser menor de 8
cv.Smooth(imagen, imagen, cv.CV_GAUSSIAN, 5, 5)
#Le aplico el filtro de Gaussian Blur y suavizo la imagen para eliminar el ruido
cv.HoughCircles(imagen, storage, cv.CV_HOUGH_GRADIENT, 1, 100)
#Aplico la funcion de "Hough Circles" para encontrar los circulos en la imagen
for n in range(0, storage.cols):
#El "Storage.cols" contiene el numero de circulos que fueron encontrados en la imagen
#For para diubjar los circulos que fueron encontrados en la imagen
r = cv.Get1D(storage, n)
#Obtengo una tupla que contiene los valores del primer circulo que sea encontrado
c = (cv.Round(r[0]), cv.Round(r[1]))
#"c" es una tupla de dos valores redondeados del "cv.round"
#contiene la posicion del circulo
cv.Circle(imagen, c, cv.Round(r[2]), cv.CV_RGB(0, 0, 0), 2)
#Dibujo el circulo
print r #Imprimiendo Tupla
print r[2] #Imprimiendo radio de circulo
#Con los radios encontrados, muestro que valor tiene la moneda
if r[2] == 67.59068298339844:
print "\nMoneda de $10 Detectada"
if r[2] == 68.31178283691406:
print "\nMoneda de $5 Detectada"
def detectar(self, imagen):
global centro
copia = cv.CloneImage(imagen)
# Tomamos imagen
dimensiones = cv.GetSize(copia)
# La transformamos a escala de grises para mayor rapidez
grises = cv.CreateImage(dimensiones, 8, 1)
cv.CvtColor(copia, grises,
cv.CV_RGB2GRAY) # cv.CvtColor(src, dst, code)
storage = cv.CreateMemStorage() # video
# Ecualizamos el histograma
cv.EqualizeHist(grises, grises)
#Suavizo la imagen para eliminar el ruido
cv.Smooth(grises, grises, cv.CV_GAUSSIAN, 5, 5)
# Cargamos el fichero cascada para ojos
ojos = cv.Load("./haarcascade_eye_tree_eyeglasses.xml")
# Reconocemos los objetos
objOjo = cv.HaarDetectObjects(copia, ojos, storage, 1.1, 2, 0,
(120, 120))
#print objOjo
mostrar = False
if 0 < len(objOjo) < 3:
#(x, y, ancho, alto) del area
#que nos interesa
area = (objOjo[0][0][0], objOjo[0][0][1], objOjo[0][0][2],
objOjo[0][0][3])
for i in objOjo:
# cortamos el area que nos interesa
cv.SetImageROI(copia, area)
# Una vez teniendo el area que nos interesa tenemos que
# aplciarle filtros para que deteccion de circulos funcione bien
image_size = cv.GetSize(copia)
gray = cv.CreateImage(image_size, 8, 1)
#Creo la matriz en la que voy a meter los posibles circulos
#Si el numero de circulos es mayor que 8, el programa no funciona
storageCir = cv.CreateMat(1, 8, cv.CV_32FC3)
# cv.CvtColor(src, dst, code)
cv.CvtColor(copia, gray, cv.CV_RGB2GRAY)
# Ecualizamos el histograma
cv.EqualizeHist(gray, gray)
#Suavizo la imagen para eliminar el ruido
cv.Smooth(gray, gray, cv.CV_GAUSSIAN, 5, 5)
# buscamos circulos.... aqui nos concentraremos en buscar la iris
#circles = cv.HoughCircles(grayImg, storage, cv.CV_HOUGH_GRADIENT, 2, 10,32,200,minRad, minRad*2)
mostrar = True
dp = 2
minDist = 200.0
param1 = 32
param2 = 60
minRadius = 12
maxRadius = 24
cv.HoughCircles(gray, storageCir, cv.CV_HOUGH_GRADIENT, dp,
minDist, param1, param2, minRadius, maxRadius)
#print storageCir.cols
#print "----"
# recorremos los circulos encontrados
for n in range(
0, storageCir.cols
): # storage.cols contiene el numero de circulos encontrados
#Obtengo la tupla que contiene los valores del primer circulo
r = cv.Get1D(storageCir, n)
#"c" es una tupla de dos valores redondeados (cv.round)
#que contiene la posicion del circulo
c = (cv.Round(r[0]), cv.Round(r[1]))
#Dibujo el circulo
# Circle(img, center, radius, color, thickness=1, lineType=8, shift=0)
cv.Circle(copia, c, cv.Round(r[2]), cv.CV_RGB(255, 1, 1),
2)
cv.Circle(copia, c, 1, cv.CV_RGB(0, 255, 0), 2)
entrenamiento = 50 #(intentos)
umbral = 10
if self.getContador() < entrenamiento:
cont = self.getContador() + 1
self.setContador(cont)
centro[0] = centro[0] + c[0]
centro[1] = centro[1] + c[1]
else:
x = centro[0] / entrenamiento
y = centro[1] / entrenamiento
print "+++"
cv.Circle(copia, (x, y), 1, cv.CV_RGB(0, 0, 255), 2)
# metemos un filtro para no tomar lo centro parecidos pero iguales
diff_x = abs(x - c[0])
diff_y = abs(y - c[1])
if diff_y > umbral and diff_x > umbral:
# hacer algo estan muy separados
print "AGUAS!"
cv.Circle(copia, c, cv.Round(r[2]),
cv.CV_RGB(255, 255, 255), 2)
mostrar = True
return copia, mostrar
