Bu yazı, görüntü işleme yöntemlerinin kullanımıyla grafik formatındaki verileri dijital formata dönüştürmek amacıyla geliştirilen bir yazılımın incelemesini sunmaktadır. Bu çalışma, grafiklerin içinde saklanan verilerin optik karakter tanıma (OCR) teknolojisi temelli bir şekilde elde edilmesini hedeflemektedir. Özellikle, grafiklerdeki verilerin metin formatına dönüştürülmesi, resim dosyalarında bulunan grafiklerin sayısal olarak anlamlı verilere dönüştürülmesi üzerine odaklanmaktadır.
Mevcut literatürde, OCR teknolojisinin genellikle metinlerin dijitalleştirilmesinde kullanıldığı bilinmektedir. Ancak, grafiklerin içerdiği verilerin aynı hassasiyetle dijitalleştirilmesine dair sınırlı çalışmalar mevcuttur. Bu yazı, grafiklerdeki farklı veri yapılarını tanımlama ve çözümleme konusunda görüntü işleme ve desen tanıma algoritmalarının kullanımını ele alarak literatüre önemli bir katkı yapmayı amaçlamaktadır. Özellikle, grafiklerdeki farklı veri tiplerinin, örneğin çizgi, sütun ve pasta dilimi gibi, tespiti ve bu verilerin anlamlı bir şekilde metin haline getirilmesi üzerinde yoğunlaşılmıştır.
Yazının ana amacı, resim formatındaki grafikleri okuyarak içerdikleri verileri tanımlamak ve bu verileri kullanıcılar için erişilebilir bir metin formatında sunmaktır. Bu hedefe ulaşmak için, OpenCV gibi görüntü işleme kütüphaneleri kullanılarak, grafiklerin tanımlanması, ayrıştırılması ve verilerin elde edilmesi için özgün bir algoritma geliştirilmiştir. Bu çalışma, özellikle endüstriyel raporlama, finansal analiz ve bilimsel veri çözümlemesi gibi alanlarda pratik uygulama potansiyeli olan önemli bir teknolojik ilerleme sunmayı hedeflemektedir. Kısa kes ve kodları göster bize diyenler için Github linki. Ayrıca burada ki açıklamaların aynılarını kodların üzerine de yazdım.
1-KÜTÜPHANELER
import cv2, imutils, re, sys, math
import xlsxwriter, json, os
import matplotlib.pyplot as plt
import numpy as np
from pathlib import Path
from matplotlib import rcParamsBu kütüphaneler, görüntü işleme uygulamanın temel kütüphanelerini içerir. cv2, görüntü işleme için kullanılan OpenCV kütüphanesini temsil eder. imutils, görüntü işleme fonksiyonlarına yardımcı olurken, re regular expressions (düzenli ifadeler) için, sys sistemle ilgili işlemler için, math matematiksel işlemler için kullanılır. xlsxwriter, Excel dosyaları oluşturmak için, json JSON işlemleri için, os işletim sistemi işlemleri için, matplotlib.pyplot ve numpy grafik ve matematiksel işlemler için kullanılır. Ayrıca, dosya yollarını yönetmek için pathlib.Path ve matplotlib parametrelerini yönetmek için matplotlib.rcParams kullanılır. Bu kütüphaneler, uygulamanın çeşitli işlevselliğini destekler ve temel işlemleri gerçekleştirmek için gereklidir.
2-Grafiklerin Yolu
grafik_yolu = '../grafikler'
Bu satır, işlenecek görüntülerin dizinini belirtir. grafik_yolu değişkeni, ‘../grafikler’ dizinindeki görüntülerin bulunduğu dosya yolu olarak tanımlanır. Bu dizin, uygulamanın işleyeceği ve dönüştüreceği görüntülerin kaynak konumunu temsil eder.
3-JSON içeriklerini yüklemek
with open('../data/urldata.json') as handler:
urldata = json.load(handler)
with open('../data/doi_data.json') as doihandler:
doidata = json.load(doihandler)
with open('../data/ocr-image-text.json') as ocrhandler:
images_text = json.load(ocrhandler)
with open('../data/aws-rekognition-output.json') as awshandler:
bbox_text = json.load(awshandler)
Bu blok, çeşitli JSON dosyalarını okuyarak içeriklerini ilgili değişkenlere yükler. İlk olarak, ../data/urldata.json dosyasını açar ve içeriğini urldata adlı değişkene yükler. Ardından, ../data/doi_data.json dosyasını doidata adlı değişkene, ../data/ocr-image-text.json dosyasını images_text adlı değişkene ve son olarak ../data/aws-rekognition-output.json dosyasını bbox_text adlı değişkene yükler. Bu dosyaların içeriği, uygulamanın işleyeceği ve üzerinde çalışacağı çeşitli veri türlerini içerir, örneğin, URL’ler, DOI verileri, OCR tarafından çıkarılan metinler veya Amazon Rekognition tarafından belirlenen sınırlayıcı kutular ve metinler gibi. Bu veri, uygulamanın işleme ve dönüştürme işlemlerini gerçekleştirmesinde kullanılacaktır. Json dosyalarını yüklemenin nedeni, görüntülerle ilişkili metin verilerine erişmek ve bu verileri işlemek içindir.
Kodun başında json dosyaları yükleniyor çünkü:
- images_text: Görüntülerdeki metinleri (OCR – Optical Character Recognition) ve bunların konumlarını içerir. Bu veriler, görüntülerin üzerindeki metinleri tanımak ve konumlarını belirlemek için kullanılır.
- bbox_text: Metin kutularının (bounding boxes) özelliklerini içerir. Metin kutuları, görüntülerdeki metin parçalarını çevreleyen dikdörtgenlerdir. Bu veriler, metinlerin ve kutularının özelliklerini elde etmek için kullanılır.
- doidata: Görüntülerin DOI (Diğer Kimlik Tanımlayıcısı) bilgisini içerir. DOI, bilimsel ve akademik yayınların benzersiz tanımlayıcısıdır. Bu veriler, görüntülerin DOI’lerini almak için kullanılır.
Bu json dosyaları, görüntülerdeki metin ve kutuları işlemek, DOI’leri almak ve son olarak Excel dosyasına veri eklemek için kullanılır.
3-Maksimum Ardışık Olanları Bulmak
def maksimumArdisikOlanlariBul(nums) -> int:
count = maxCount = 0
for i in range(len(nums)):
if nums[i] == 1:
count += 1
else:
maxCount = max(count, maxCount)
count = 0
return max(count, maxCount)Bu fonksiyon, bir listenin içinde en uzun ardışık 1’leri bulmayı amaçlar. Fonksiyon, girdi olarak bir liste alır (nums) ve ardışık 1’lerin en uzun dizisini bulmak için bir döngü kullanır. count değişkeni, mevcut ardışık 1’lerin sayısını tutar, maxCount ise bulunan en uzun ardışık 1’lerin sayısını saklar.
Döngü içinde, liste elemanları kontrol edilir. Eğer eleman 1 ise, count arttırılır. Eğer eleman 0 ise, mevcut ardışık 1’lerin sayısı maxCount ile karşılaştırılır ve daha önce bulunan en uzun ardışık 1’lerin sayısından büyükse maxCount güncellenir. Ardından count sıfırlanır.
Döngü sona erdikten sonra, en uzun ardışık 1’leri bulmak için son bir karşılaştırma yapılır (max(count, maxCount)) ve sonuç geri döndürülür. Bu fonksiyon, verilen bir listenin içindeki en uzun ardışık 1 dizisinin uzunluğunu döndürür.
Ardışık 1’lerin uzunluğunu belirli bir deseni veya nesneyi tanımlamak için kullanılır.
4-Eksen tespiti
def eksenTespiti(filepath, threshold=None, debug=False):
if filepath is None:
return None, None
if threshold is None:
threshold = 10
image = cv2.imread(filepath)
height, width, channels = image.shape
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
maksimumArdisikBirler = [maksimumArdisikOlanlariBul(gray[:, idx] < 200) for idx in range(width)]
start_idx, maxindex, maxcount = 0, 0, max(maksimumArdisikBirler)
while start_idx < width:
if abs(maksimumArdisikBirler[start_idx] - maxcount) <= threshold:
maxindex = start_idx
break
start_idx += 1
yaxis = (maxindex, 0, maxindex, height)
if debug:
fig, ax = plt.subplots(1, 2)
ax[0].imshow(image)
ax[1].plot(maksimumArdisikBirler, color = 'k')
ax[1].axhline(y = max(maksimumArdisikBirler) - 10, color = 'r', linestyle = 'dashed')
ax[1].axhline(y = max(maksimumArdisikBirler) + 10, color = 'r', linestyle = 'dashed')
ax[1].vlines(x = maxindex, ymin = 0.0, ymax = maksimumArdisikBirler[maxindex], color = 'b', linewidth = 4)
plt.show()
maksimumArdisikBirler = [maksimumArdisikOlanlariBul(gray[idx, :] < 200) for idx in range(height)]
start_idx, maxindex, maxcount = 0, 0, max(maksimumArdisikBirler)
while start_idx < height:
if abs(maksimumArdisikBirler[start_idx] - maxcount) <= threshold:
maxindex = start_idx
start_idx += 1
cv2.line(image, (0, maxindex), (width, maxindex), (255, 0, 0), 2)
xaxis = (0, maxindex, width, maxindex)
if debug:
rcParams['figure.figsize'] = 15, 8
fig, ax = plt.subplots(1, 1)
ax.imshow(image, aspect = 'auto')
return xaxis, yaxisBu fonksiyon, belirli bir dosyadaki grafikteki eksenleri tespit etmeyi amaçlar. Fonksiyon, dosya yolu (filepath), bir eşik değeri (threshold) ve hata ayıklama modu (debug) parametreleri alır. Fonksiyonun başında, belirli koşullar sağlanmazsa None değerleri döndürülür.
Eğer threshold belirtilmemişse, varsayılan olarak 10 atanır. Ardından, belirtilen dosya yolu kullanılarak bir görüntü okunur ve gri tonlamaya dönüştürülür (cv2.cvtColor). Görüntünün genişliği, yüksekliği ve kanal sayısı alınır.
Fonksiyon, ardışık 1’leri sayan maksimumArdisikOlanlariBul fonksiyonunu kullanarak yatay ve dikey eksenleri tespit eder. maksimumArdisikBirler listeleri oluşturularak her sütun ve satır için ardışık 1’lerin sayısı hesaplanır. Bu değerler kullanılarak yatay ve dikey eksenler belirlenir. Ardışık 1’lerin sayısı en fazla olan sütun veya satır eksen olarak kabul edilir.
Eğer hata ayıklama modu aktifse (debug=True), bir dizi görselleştirme işlemi gerçekleştirilir. Yatay eksen için bir subplot içinde orijinal görüntü ile ardışık 1’lerin sayılarını içeren bir çizgi grafiği gösterilir. Dikey eksen için ise orijinal görüntü üzerinde belirtilen eksen çizgisi çizilir.
Son olarak, tespit edilen yatay ve dikey eksenler xaxis ve yaxis olarak döndürülür.
5-Metini Temizleme
def metiniTemizleme(image_text):
return [(text, (textx, texty, w, h)) for text, (textx, texty, w, h) in image_text if text.strip() != 'I']Bu fonksiyon, OCR (Optical Character Recognition) tarafından çıkarılan metinleri temizlemek için kullanılır. Fonksiyon, bir liste olarak verilen image_text parametresini alır ve bu liste içindeki her metni ve ilgili koordinatları kontrol eder. Metin içeriğinde yalnızca boşluklardan oluşan ve “I” karakterinden farklı olan öğeleri korur. Yani, metin içeriği “I” karakterinden oluşan öğeler bu temizleme işlemi sonucunda filtrelenmiş olur.
Fonksiyon, temizlenmiş metinleri ve ilgili koordinatları içeren bir liste döndürür. Temizleme işlemi, metin içeriğinin “I” karakterinden farklı olup olmadığını kontrol ederek gerçekleştirilir.
6-Olası Etiketlemeleri Yapmak
def olasiEtiketleriAl(image, image_text, xaxis, yaxis):
y_labels = []
x_labels = []
legends = []
y_text_list = []
height, width, channels = image.shape
(x1, y1, x2, y2) = xaxis
(x11, y11, x22, y22) = yaxis
image_text = metiniTemizleme(image_text)
for text, (textx, texty, w, h) in image_text:
text = text.strip()
if (np.sign((x2 - x1) * (texty - y1) - (y2 - y1) * (textx - x1)) == -1 and
np.sign((x22 - x11) * (texty - y11) - (y22 - y11) * (textx - x11)) == 1):
numbers = re.findall(r'^[+-]?\d+(?:\.\d+)?[%-]?$', text)
if bool(numbers):
y_labels.append((text, (textx, texty, w, h)))
else:
y_text_list.append((text, (textx, texty, w, h)))
elif (np.sign((x2 - x1) * (texty - y1) - (y2 - y1) * (textx - x1)) == 1 and
np.sign((x22 - x11) * (texty - y11) - (y22 - y11) * (textx - x11)) == -1):
x_labels.append((text, (textx, texty, w, h)))
elif (np.sign((x2 - x1) * (texty - y1) - (y2 - y1) * (textx - x1)) == -1 and
np.sign((x22 - x11) * (texty - y11) - (y22 - y11) * (textx - x11)) == -1):
legends.append((text, (textx, texty, w, h)))
maxIntersection = 0
maxList = []
for i in range(x11):
count = 0
current = []
for index, (text, rect) in enumerate(y_labels):
if cizgiXDikdortgenleKesisiyorMu(i, rect):
count += 1
current.append(y_labels[index])
if count > maxIntersection:
maxIntersection = count
maxList = current
y_labels_list = maxList.copy()
y_labels = []
for text, (textx, texty, w, h) in maxList:
y_labels.append(text)
maxIntersection = 0
maxList = []
for i in range(y1, height):
count = 0
current = []
for index, (text, rect) in enumerate(x_labels):
if cizgiYDikdortgenleKesisiyorMu(i, rect):
count += 1
current.append(x_labels[index])
if count > maxIntersection:
maxIntersection = count
maxList = current
x_labels_list = maxList.copy()
x_text = x_labels.copy()
x_labels = []
hmax = 0
for text, (textx, texty, w, h) in maxList:
x_labels.append(text)
if texty + h > hmax:
hmax = texty + h
maxIntersection = 0
maxList = []
for i in range(hmax + 1, height):
count = 0
current = []
for index, (text, rect) in enumerate(x_text):
if cizgiYDikdortgenleKesisiyorMu(i, rect):
count += 1
current.append(x_text[index])
if count > maxIntersection:
maxIntersection = count
maxList = current
x_text = []
for text, (textx, texty, w, h) in maxList:
x_text.append(text)
legends_and_numbers = metinKutulariniBirlestir(legends)
legends = []
for text, (textx, texty, w, h) in legends_and_numbers:
if not re.search(r'^([(+-]*?(\d+)?(?:\.\d+)*?[-%) ]*?)*$', text):
legends.append((text, (textx, texty, w, h)))
def canMerge(group, candidate):
candText, candRect = candidate
candx, candy, candw, candh = candRect
for memText, memRect in group:
memx, memy, memw, memh = memRect
if abs(candy - memy) <= 5 and abs(candy + candh - memy - memh) <= 5:
return True
elif abs(candx - memx) <= 5:
return True
return False
legend_groups = []
for index, (text, rect) in enumerate(legends):
for groupid, group in enumerate(legend_groups):
if canMerge(group, (text, rect)):
group.append((text, rect))
break
else:
legend_groups.append([(text, rect)])
maxList = []
if len(legend_groups) > 0:
maxList = max(legend_groups, key = len)
legends = []
for text, (textx, texty, w, h) in maxList:
legends.append(text)
return image, x_labels, x_labels_list, x_text, y_labels, y_labels_list, y_text_list, legends, maxList
Bu fonksiyon, verilen bir görüntü, OCR tarafından çıkarılan metinler, ve tespit edilen x ve y eksenleri ile muhtemel etiketleri belirlemek için kullanılır. Fonksiyon, girdi olarak bir görüntü (image), OCR tarafından çıkarılan metinler (image_text), x ekseninin koordinatları (xaxis) ve y ekseninin koordinatları (yaxis) alır.
Fonksiyon, öncelikle metiniTemizleme fonksiyonunu kullanarak OCR çıktısındaki metinleri temizler. Ardından, x ve y eksenleri arasında kalan metinleri, etiketler, ve legendaları belirlemek için çeşitli koşullar kullanır. Bu koşullar, metinlerin belirli bir bölgede bulunup bulunmadığını kontrol eder ve bu bölgede bulunan metinlerin türüne göre ayrıştırma yapar.
Fonksiyon, x eksenine ait etiketleri, y eksenine ait etiketleri, x eksenine ait metinleri, y eksenine ait metinleri döndürür. Ayrıca, bu metinlerin koordinatlarını içeren ilgili listeleri de döndürür. Hata ayıklama modu (debug) aktifse, çeşitli görselleştirmeleri içeren bir dizi grafik de gösterilir. Bu fonksiyon, görüntü üzerindeki etiketleri ve metinleri tespit etmek için kullanılır ve bu bilgiler, daha sonraki aşamalarda kullanılmak üzere elde edilir.
7-Kesişme Kontrolleri
def cizgiXDikdortgenleKesisiyorMu(candx, rect):
(x, y, w, h) = rect
if x <= candx <= x + w:
return True
else:
return False
def cizgiYDikdortgenleKesisiyorMu(candy, rect):
(x, y, w, h) = rect
if y <= candy <= y + h:
return True
else:
return FalseBu iki fonksiyon, bir çizginin (yatay veya dikey) belirli bir dikdörtgen ile kesişip kesişmediğini kontrol eder.
cizgiXDikdortgenleKesisiyorMu fonksiyonu, bir yatay çizginin belirli bir dikdörtgen ile kesişip kesişmediğini kontrol eder. candx parametresi, çizginin x koordinatını temsil eder, ve rect parametresi, dikdörtgenin (x, y, w, h) koordinatlarını içerir. Eğer çizginin x koordinatı, dikdörtgenin sol üst köşesinin x koordinatı ile sağ üst köşesinin x koordinatı arasında bulunuyorsa, çizgi dikdörtgenle kesişir ve True değeri döndürülür.
cizgiYDikdortgenleKesisiyorMu fonksiyonu ise, bir dikey çizginin belirli bir dikdörtgen ile kesişip kesişmediğini kontrol eder. candy parametresi, çizginin y koordinatını temsil eder, ve rect parametresi, dikdörtgenin (x, y, w, h) koordinatlarını içerir. Eğer çizginin y koordinatı, dikdörtgenin sol üst köşesinin y koordinatı ile sağ alt köşesinin y koordinatı arasında bulunuyorsa, çizgi dikdörtgenle kesişir ve True değeri döndürülür.
Bu fonksiyonlar, çeşitli noktaların veya çizgilerin dikdörtgen içinde veya dışında olup olmadığını kontrol etmek için kullanılabilir. Bu uygulamada, yatay veya dikey çizgilerin x veya y koordinatları, belirli bir dikdörtgenin içinde olup olmadığını kontrol etmek için kullanılır.
8-Metin ve Eksenler Kullanılarak Oran Hesaplamak
def oranAl(path, xaxis, yaxis):
list_text = []
list_ticks = []
filepath = grafik_yolu + "/" + path.name
image = cv2.imread(filepath)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
height, width, channels = image.shape
image_text = images_text[path.name]
for text, (textx, texty, w, h) in image_text:
text = text.strip()
(x1, y1, x2, y2) = xaxis
(x11, y11, x22, y22) = yaxis
if (np.sign((x2 - x1) * (texty - y1) - (y2 - y1) * (textx - x1)) == -1 and
np.sign((x22 - x11) * (texty - y11) - (y22 - y11) * (textx - x11)) == 1):
numbers = re.findall(r'\d+(?:\.\d+)?', text)
if bool(numbers):
list_text.append((numbers[0], (textx, texty, w, h)))
maxIntersection = 0
maxList = []
for i in range(x11):
count = 0
current = []
for index, (text, rect) in enumerate(list_text):
if cizgiXDikdortgenleKesisiyorMu(i, rect):
count += 1
current.append(list_text[index])
if count > maxIntersection:
maxIntersection = count
maxList = current
list_text = []
for text, (textx, texty, w, h) in maxList:
list_text.append(float(text))
list_ticks.append(float(texty + h))
text_sorted = (sorted(list_text))
ticks_sorted = (sorted(list_ticks))
ticks_diff = ([ticks_sorted[i] - ticks_sorted[i-1] for i in range(1, len(ticks_sorted))])
text_diff = ([text_sorted[i] - text_sorted[i-1] for i in range(1, len(text_sorted))])
print("[get text-to-tick ratio] ticks_diff: {0}, text_diff: {1}".format(ticks_diff, text_diff))
ticks_diff = aykiri_degerleri_reddet(np.array(ticks_diff), m=1)
text_diff = aykiri_degerleri_reddet(np.array(text_diff), m=1)
print("[aykiri_degerleri_reddet] ticks_diff: {0}, text_diff: {1}".format(ticks_diff, text_diff))
normalize_ratio = np.array(text_diff).mean() / np.array(ticks_diff).mean()
return text_sorted, normalize_ratioBu fonksiyon, belirli bir görüntü dosyasındaki metinlerin x ve y eksenleri arasındaki oranı hesaplar. path parametresi, görüntü dosyasının yolu ve adını içerir. xaxis ve yaxis parametreleri, tespit edilen x ve y eksenlerini içerir.
Fonksiyon, öncelikle belirtilen görüntü dosyasını okur ve RGB formatına dönüştürür. Ardından, OCR tarafından çıkarılan metinler içinde y eksenindeki metinleri bulur. Bu metinlerin içerdiği sayısal değerleri alır ve list_text listesine ekler.
Daha sonra, y eksenindeki metinlerin belirli bir bölgesine düşen metinlerin oranını hesaplar. Bunun için, metinlerin y koordinatları ve aralarındaki farklar incelenir. Bu farklar, eksen üzerindeki ölçeklemeyi temsil eder. Bu ölçeklemeyi temsil eden değerlerden oran hesaplanır.
Son olarak, bu oran normalize edilir ve text_sorted adlı sıralanmış metinler listesi ile birlikte döndürülür. Bu fonksiyon, belirli bir görüntü dosyasındaki x ve y eksenlerinin oranını bulur ve bu oranı kullanarak metinlerin eksen üzerindeki ölçeklemesini analiz eder.
9-Aykırı Değerleri Reddetmek
def aykiri_degerleri_reddet(data, m=1):
return data[abs(data - np.mean(data)) <= m * np.std(data)]Bu fonksiyon, verilen bir veri setindeki aykırı değerleri (outliers) reddeder. data parametresi, veri setini içerir ve m parametresi, aykırı değerlerin ne kadar uzaklıkta olduğunu belirten bir çarpandır.
Fonksiyon, veri setinin ortalaması ve standart sapmasını kullanarak aykırı değerleri belirler. Veri setinden, ortalamadan belli bir standart sapma miktarı kadar uzaklıkta olan değerler korunur ve geri kalanlar reddedilir. Bu sayede, veri setindeki anormal veya aykırı değerlerden etkilenmeden, veri setinin genel eğilimine daha iyi uyum sağlayan bir alt küme elde edilir.
Bu fonksiyon, veri analizi veya modelleme gibi durumlarda, veri setindeki anormal değerlerin etkisini azaltmak veya ortadan kaldırmak için kullanılır. Bu, veri setinin daha güvenilir bir şekilde analiz edilmesine veya modelin daha iyi sonuçlar vermesine yardımcı olur.
10-Excel’e Veri Ekleme İşlemi
def exceleEkle(dataname, data, row):
col = 0
worksheet.write(row, col, dataname)
for content in data:
col += 1
worksheet.write(row, col, content)Bu fonksiyon, belirli bir veri setini Excel çalışma sayfasına eklemek için kullanılır. dataname parametresi, veri setinin adını veya başlığını temsil eder. data parametresi, Excel’e eklenmek istenen veri setini içerir. row parametresi, verilerin hangi satıra eklenmesi gerektiğini belirtir.
Fonksiyon, belirtilen veri setinin başlığını ve içeriğini sırasıyla belirtilen satır ve sütunlara ekler. İlk olarak, veri setinin adı veya başlığı (dataname) belirtilen satırın ilk sütununa (col=0) yazılır. Daha sonra, veri setinin içeriği (data) sırasıyla bir sonraki sütuna (col+=1) yazılır.
11-Dikdörtgen Birleştirme
def dikdortgenleriBirlestir(contours, mode='contours'):
rects = []
rectsUsed = []
for cnt in contours:
if mode == 'contours':
rects.append(cv2.boundingRect(cnt))
elif mode == 'rects':
rects.append(cnt)
rectsUsed.append(False)
def getXFromRect(item):
return item[0]
rects.sort(key = getXFromRect)
acceptedRects = []
xThr = 5
yThr = 5
for supIdx, supVal in enumerate(rects):
if (rectsUsed[supIdx] == False):
currxMin = supVal[0]
currxMax = supVal[0] + supVal[2]
curryMin = supVal[1]
curryMax = supVal[1] + supVal[3]
rectsUsed[supIdx] = True
for subIdx, subVal in enumerate(rects[(supIdx+1):], start = (supIdx+1)):
candxMin = subVal[0]
candxMax = subVal[0] + subVal[2]
candyMin = subVal[1]
candyMax = subVal[1] + subVal[3]
if (candxMin <= currxMax + xThr):
if not dikdortgeneYakinlik((candxMin, candyMin, candxMax - candxMin, candyMax - candyMin),
(currxMin, curryMin, currxMax - currxMin, curryMax - curryMin), yThr):
break
currxMax = candxMax
curryMin = min(curryMin, candyMin)
curryMax = max(curryMax, candyMax)
rectsUsed[subIdx] = True
else:
break
acceptedRects.append([currxMin, curryMin, currxMax - currxMin, curryMax - curryMin])
return acceptedRectsBu fonksiyon, belirli kontur veya dikdörtgenlerin listesini alarak bu dikdörtgenlerin birleştirilmiş versiyonunu oluşturur. contours parametresi, bir dizi kontur veya dikdörtgeni içerir. mode parametresi, kullanılan modu belirtir ve varsayılan olarak ‘contours’ değerini alır.
Fonksiyon, önce verilen konturları veya dikdörtgenleri kullanarak bir dikdörtgen listesi oluşturur. Daha sonra, dikdörtgenleri x koordinatına göre sıralar. Ardından, belirli bir mesafe eşiği (threshold) kullanarak yakındaki dikdörtgenleri birleştirir.
Dikdörtgenlerin birleştirilmesi işlemi, her dikdörtgenin sağ üst köşesinin sol alt köşesine kadar olan mesafenin, belirtilen mesafe eşiği (xThr ve yThr) kadar olup olmadığını kontrol eder. Eğer bu mesafe eşiğine uyan dikdörtgenler bulunursa, bu dikdörtgenler birleştirilir ve tek bir dikdörtgen olarak kabul edilir.
Son olarak, birleştirilmiş dikdörtgenlerin listesi döndürülür. Bu fonksiyon, belirli bölgelerin birleştirilmesi ve tek bir bölge olarak kabul edilmesi gerektiğinde kullanılır. Bu, nesnelerin sınırlarının belirlenmesi veya bölgelerin tanımlanması gibi işlemlerde faydalı olur.
12-Metin Kutularını Birleştirme
def metinKutulariniBirlestir(textboxes):
rects = []
rectsUsed = []
for box in textboxes:
rects.append(box)
rectsUsed.append(False)
def getXFromRect(item):
return item[1][0]
def getYFromRect(item):
return item[1][1]
rects.sort(key = lambda x: (getYFromRect, getXFromRect))
acceptedRects = []
xThr = 10
yThr = 0
for supIdx, supVal in enumerate(rects):
if (rectsUsed[supIdx] == False):
currxMin = supVal[1][0]
currxMax = supVal[1][0] + supVal[1][2]
curryMin = supVal[1][1]
curryMax = supVal[1][1] + supVal[1][3]
currText = supVal[0]
rectsUsed[supIdx] = True
for subIdx, subVal in enumerate(rects[(supIdx+1):], start = (supIdx+1)):
candxMin = subVal[1][0]
candxMax = subVal[1][0] + subVal[1][2]
candyMin = subVal[1][1]
candyMax = subVal[1][1] + subVal[1][3]
candText = subVal[0]
if (candxMin <= currxMax + xThr):
if not dikdortgeneYakinlik((candxMin, candyMin, candxMax - candxMin, candyMax - candyMin),
(currxMin, curryMin, currxMax - currxMin, curryMax - curryMin), yThr):
break
currxMax = candxMax
curryMin = min(curryMin, candyMin)
curryMax = max(curryMax, candyMax)
currText = currText + ' ' + candText
rectsUsed[subIdx] = True
else:
break
acceptedRects.append([currText, (currxMin, curryMin, currxMax - currxMin, curryMax - curryMin)])
return acceptedRectsBu fonksiyon, metin kutularının listesini alarak birleştirilmiş metin kutularının listesini oluşturur.
Fonksiyon, öncelikle verilen metin kutularını bir liste olarak alır. Her bir metin kutusu, metnin kendisi ve bu metnin bulunduğu dikdörtgenin koordinatlarını içerir. Daha sonra, metin kutularını, dikdörtgenlerin sol üst köşelerine göre sıralar.
Sonra, belirli bir mesafe eşiği (threshold) kullanarak yakındaki metin kutularını birleştirir. Birleştirme işlemi, her metin kutusunun sağ üst köşesinin sol alt köşesine kadar olan mesafenin, belirtilen mesafe eşiği (xThr ve yThr) kadar olup olmadığını kontrol eder. Eğer bu mesafe eşiğine uyan metin kutuları bulunursa, bu metin kutuları birleştirilir ve tek bir metin kutusu olarak kabul edilir.
Son olarak, birleştirilmiş metin kutularının listesi döndürülür. Bu fonksiyon, özellikle optik karakter tanıma (OCR) sonuçlarını birleştirme ve düzenleme gerektiğinde kullanılır. Örneğin, OCR tarafından tanınan metin kutularının bazıları gereğinden fazla parçalanmış olabilir; bu durumda, bu fonksiyon kullanılarak metin kutuları birleştirilerek daha tutarlı bir metin kutusu çıktısı elde edilir.
13-Yakındaki Dikdörtgen Kontrolü
def dikdortgeneYakinlik(current, candidate, threshold):
(currx, curry, currw, currh) = current
(candx, candy, candw, candh) = candidate
currxmin = currx
currymin = curry
currxmax = currx + currw
currymax = curry + currh
candxmin = candx
candymin = candy
candxmax = candx + candw
candymax = candy + candh
if candymax <= currymin and candymax + threshold >= currymin:
return True
if candymin >= currymax and currymax + threshold >= candymin:
return True
if candymax >= currymin and candymin <= currymin:
return True
if currymax >= candymin and currymin <= candymin:
return True
if (candymin >= currymin and
candymin <= currymax and
candymax >= currymin and
candymax <= currymax):
return True
return FalseBu fonksiyon, iki dikdörtgenin yakınlığını kontrol eder ve birleştirme işlemi için uygun olup olmadığını belirler.
Fonksiyon, iki dikdörtgenin koordinatlarını ve bir mesafe eşiğini (threshold) alır. İki dikdörtgenin yakınlığını kontrol etmek için, dikdörtgenlerin alt ve üst sınırlarını kontrol eder. Eğer bir dikdörtgenin üst sınırı, diğerinin alt sınırından daha yakın ise veya bu iki sınır arasındaki mesafe belirtilen eşik değeriyle uyumluluk gösteriyorsa, bu dikdörtgenler birbirine yakındır ve birleştirilebilir.
Bu fonksiyon, dikdörtgenlerin birleştirilip birleştirilemeyeceğini belirlemek için kullanılır. Özellikle, metin kutularının birleştirilmesi veya kontur birleştirme gibi işlemlerde dikdörtgenlerin yakınlığını kontrol etmek için kullanılır. Bu sayede, birbirine yakın olan dikdörtgenlerin birleştirilmesiyle daha büyük ve daha tutarlı bir dikdörtgen elde edilir.
14-Matematiksel Hesaplama ve Geometrik İşlevler
def oklid(v1, v2):
return sum((p - q) ** 2 for p, q in zip(v1, v2)) ** .5
def aralarindaki_aci(p1, p2):
deltaX = p1[0] - p2[0]
deltaY = p1[1] - p2[1]
return math.atan2(deltaY, deltaX) / math.pi * 180
def dikdortgenlerArasiMesafe(rectA, rectB):
(rectAx, rectAy, rectAw, rectAh) = rectA
(rectBx, rectBy, rectBw, rectBh) = rectB
return abs(rectAx + rectAx / 2 - rectBx - rectBx / 2)Bu bölümde, çeşitli matematiksel ve geometrik işlevler tanımlanmıştır.
oklid: İki vektör arasındaki Öklid mesafesini hesaplar. İki vektörü alır (v1vev2), her bir bileşenin farkının karesini alır, bu değerleri toplar ve karekökünü alarak Öklid mesafesini hesaplar.aralarindaki_aci: İki nokta arasındaki açıyı derece cinsinden hesaplar. İki noktayı alır (p1vep2), bu noktalar arasındaki x ve y koordinatlarındaki farkları kullanarak atan2 fonksiyonunu kullanır ve sonucu dereceye dönüştürür.dikdortgenlerArasiMesafe: İki dikdörtgen arasındaki mesafeyi hesaplar. İki dikdörtgenin koordinatlarını alır (rectAverectB), bu dikdörtgenlerin merkezlerinin x ve y koordinatlarındaki farkların mutlak değerlerini alır.
15-Muhtemel Y Eksen Etiketlerini Bulmak
def muhtemelYEtiketleriniAlma(image, contours, xaxis, yaxis):
y_labels = []
height, width, channels = image.shape
(x1, y1, x2, y2) = xaxis
(x11, y11, x22, y22) = yaxis
maxIntersection = 0
maxList = []
for i in range(x11):
count = 0
current = []
for index, rect in enumerate(contours):
if cizgiXDikdortgenleKesisiyorMu(i, rect):
count += 1
current.append(contours[index])
if count > maxIntersection:
maxIntersection = count
maxList = current
return image, maxListBu fonksiyon, verilen görüntü ve kontur listesi üzerinde işlem yaparak muhtemel Y eksen etiketlerini belirler.
Fonksiyon, bir görüntü ve kontur listesi (contours) alır, ayrıca X ve Y eksenlerinin koordinatlarını (xaxis ve yaxis) alır. İşlem sırasında, X eksenine dik olan dikey çizgilerin Y eksenini kesen konturlarını bulur. Ardından, bu konturlar arasından en fazla kesişime sahip olanları seçer ve muhtemel Y eksen etiketlerini içeren bir listeyi döndürür.
Bu fonksiyon, özellikle grafiklerin veya çizelgelerin Y eksenindeki etiketleri belirlemek için kullanılır. Bu etiketler daha sonra grafiklerin yorumlanması veya analiz edilmesi için kullanılır.
16-Noktaları Genişletme
def genislet(points, margin):
return np.array([
[[points[0][0][0] - margin, points[0][0][1] - margin]],
[[points[1][0][0] + margin, points[1][0][1] - margin]],
[[points[2][0][0] + margin, points[2][0][1] + margin]],
[[points[3][0][0] - margin, points[3][0][1] + margin]]])Bu işlev, bir dizi noktayı (dörtgen koordinatları gibi) ve bir marjı alır ve bu noktaları belirtilen marjla genişletir.
Fonksiyon, bir dizi nokta ve bir marj değeri alır (points ve margin). Bu noktalar genellikle dörtgenin köşelerini temsil eder. İşlev, her bir noktanın x ve y koordinatlarına belirtilen marj değerini ekleyerek veya çıkararak, orijinal dörtgeni genişletir veya daraltır.
17-Y Eksen Değerlerini Belirlemek
images = []
texts = []
def YDegerleriniAl(grafik_yolu):
yValueDict = {}
for index, path in enumerate(Path(grafik_yolu).iterdir()):
if path.name.endswith('.png') or path.name.endswith('.jpg'):
filepath = grafik_yolu + "/" + path.name
img = cv2.imread(filepath)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_height, img_width, _ = img.shape
xaxis, yaxis = eksenTespiti(filepath)
for (x1, y1, x2, y2) in [xaxis]:
xaxis = (x1, y1, x2, y2)
for (x1, y1, x2, y2) in [yaxis]:
yaxis = (x1, y1, x2, y2)
image_text = images_text[path.name]
img, x_labels, x_labels_list, _, _, _, _, legends, legendBoxes = olasiEtiketleriAl(img, image_text, xaxis, yaxis)
actual_image = img.copy()
try:
list_text, normalize_ratio = oranAl(path, xaxis, yaxis)
print("[YDegerleriniAl] legends: {0}".format(legends))
print("[{0}] path: {1}, ratio: {2}".format(index, path.name, normalize_ratio), end='\n\n')
texts = bbox_text[path.name]['TextDetections']
for text in texts:
if text['Type'] == 'WORD' and text['Confidence'] >= 80:
vertices = [[vertex['X'] * img_width, vertex['Y'] * img_height] for vertex in text['Geometry']['Polygon']]
vertices = np.array(vertices, np.int32)
vertices = vertices.reshape((-1, 1, 2))
img = cv2.fillPoly(img, [genislet(vertices, 1)], (255, 255, 255))
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
threshold = cv2.threshold(gray, 200, 255, cv2.THRESH_BINARY)[1]
contours, _ = cv2.findContours(threshold, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
contours = [contour for contour in contours if cv2.contourArea(contour) < 0.01 * img_height * img_width]
contours = [cv2.approxPolyDP(contour, 3, True) for contour in contours]
rects = [cv2.boundingRect(contour) for contour in contours]
groups = []
legendtexts = []
legendrects = []
for box in legendBoxes:
text, (textx, texty, width, height) = box
bboxes = dikdortgenFiltrele(rects, box)
if bboxes is not None:
for rect in [bboxes]:
(x, y, w, h) = rect
legendrects.append(rect)
group = dikdortgenGrupla(actual_image, rect)[0]
group = [arr.tolist() for arr in group]
groups.append(group)
legendtexts.append(text)
cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 3)
cv2.rectangle(img, (textx, texty), (textx + width, texty + height), (255, 0, 0), 2)
data = {}
for legend in legends:
data[legend] = {}
for x_label, box in x_labels_list:
data[legend][x_label] = 0.0
for i in range(len(groups)):
img = cv2.imread(grafik_yolu + "/" + path.name)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
legendtext = legendtexts[i]
for box in legendrects:
(textx, texty, width, height) = box
cv2.rectangle(img, (textx, texty), (textx + width, texty + height), (255, 255, 255), cv2.FILLED)
mask = None
for value in groups[i]:
COLOR_MIN = np.array([value[0], value[1], value[2]], np.uint8)
COLOR_MAX = np.array([value[0], value[1], value[2]], np.uint8)
if mask is None:
mask = cv2.inRange(img, COLOR_MIN, COLOR_MAX)
else:
mask = mask | cv2.inRange(img, COLOR_MIN, COLOR_MAX)
image = cv2.bitwise_and(img, img, mask = mask)
image = cv2.morphologyEx(image, cv2.MORPH_CLOSE, (3, 3))
edged = cv2.Canny(image, 0, 250)
contours, _ = cv2.findContours(edged, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
contours = [contour for contour in contours if cv2.contourArea(contour) > 0.]
if len(contours) == 0 or len(contours) > 100:
continue
contours = [cv2.approxPolyDP(contour, 3, True) for contour in contours]
rects = dikdortgenleriBirlestir(contours)
textBoxes = []
labels = []
for rectBox in rects:
min_distance = sys.maxsize
closestBox = None
labeltext = None
for text, textBox in x_labels_list:
if dikdortgenlerArasiMesafe(rectBox, textBox) < min_distance:
closestBox = textBox
min_distance = dikdortgenlerArasiMesafe(rectBox, textBox)
labeltext = text
textBoxes.append(closestBox)
labels.append(labeltext)
list_len = []
for rect in rects:
list_len.append((rect, float(rect[3])))
y_val = [(rect, round(l* normalize_ratio, 1)) for rect, l in list_len]
for x_label, box in x_labels_list:
(x, y, w, h) = box
value = 0.0
closest = None
dist = sys.maxsize
for index, item in enumerate(y_val):
if labels[index] == x_label:
(vx, vy, vw, vh) = item[0]
if abs(x + w/2 - vx - vw/2) < dist:
dist = abs(x + w/2 - vx - vw/2)
closest = item[0]
value = item[1]
data[legendtext][x_label] = value
yValueDict[path.name] = data
except Exception as e:
print(e)
continue
return yValueDict
Bu işlev, bir dizi görüntüyü işler ve her bir görüntünün Y eksen değerlerini belirler.
Fonksiyon, verilen bir görüntü dizini (grafik_yolu) içindeki her bir görüntüyü alır. Her bir görüntü üzerinde işlem yapar ve X ve Y eksenlerini tespit eder. Daha sonra bu eksenlerle ilişkilendirilen etiketler ve diğer metinler arasındaki ilişkiyi kullanarak Y eksen değerlerini belirler.
İşlev, özellikle grafiklerin veya çizelgelerin Y eksenindeki değerleri belirlemek için tasarlanmıştır. Bu değerler, görüntüdeki çeşitli metinlerin ve nesnelerin konumlarına dayanarak hesaplanır. Bu değerler daha sonra veri analizi veya görüntü yorumlama gibi amaçlarla kullanılacaktır.
18-Etiket Kutularını Filtrelemek
def dikdortgenFiltrele(rects, legendBox):
text, (textx, texty, width, height) = legendBox
filtered = []
for rect in rects:
(x, y, w, h) = rect
if abs(y - texty) <= 10 and abs(y - texty + h - height) <= 10:
filtered.append(rect)
filtered = dikdortgenleriBirlestir(filtered, 'rects')
closest = None
dist = sys.maxsize
for rect in filtered:
(x, y, w, h) = rect
if abs(x + w - textx) <= dist:
dist = abs(x + w - textx)
closest = rect
return closestBu işlev, belirli bir etiket kutusu için ilgili dikdörtgenleri filtreler ve en yakın olanı seçer.
Fonksiyon, dikdörtgen listesini (rects) ve bir etiket kutusunu (legendBox) alır. İlk olarak, etiket kutusuna yakın olan dikdörtgenleri belirlemek için bir filtreleme işlemi yapar. Bu, dikdörtgenlerin etiket kutusuna yakın olup olmadığını kontrol ederek gerçekleştirilir. Ardından, filtrelenmiş dikdörtgenler arasından en yakın olanı seçer.
Bu işlev, bir etiket kutusuyla ilişkilendirilmiş dikdörtgenleri bulmak ve bunlar arasından en uygun olanı seçmek için kullanılır.
19-Kutu Gruplamak
def dikdortgenGrupla(img, box):
(x, y, w, h) = box
image = img[y:y+h, x:x+w].reshape((h * w, 3))
values, counts = np.unique(image, axis = 0, return_counts = True)
threshold = 5
for r in range(255 - threshold, 256):
for g in range(255 - threshold, 256):
for b in range(255 - threshold, 256):
image = image[np.where((image != [r, g, b]).any(axis = 1))]
values, counts = np.unique(image, axis = 0, return_counts = True)
sort_indices = np.argsort(-counts)
values, counts = values[sort_indices], counts[sort_indices]
groups = []
groupcounts = []
for idx, value in enumerate(values):
grouped = False
for groupid, group in enumerate(groups):
for member in group:
r, g, b = member
vr, vg, vb = value
if (abs(vr.astype(np.int16) - r.astype(np.int16)) <= 5 and
abs(vg.astype(np.int16) - g.astype(np.int16)) <= 5 and
abs(vb.astype(np.int16) - b.astype(np.int16)) <= 5):
group.append(value)
groupcounts[groupid] += counts[idx]
grouped = True
break
if grouped:
break
if not grouped:
groups.append([value])
groupcounts.append(counts[idx])
groupcounts = np.array(groupcounts)
sort_indices = np.argsort(-groupcounts)
new_groups = [groups[i] for i in sort_indices]
groups = new_groups
return groups
Bu işlev, bir dikdörtgenin içindeki renk gruplarını tespit etmek için kullanılır.
Fonksiyon, bir görüntü ve bir dikdörtgen alır. Dikdörtgenin içindeki pikselleri alır, bunları renk gruplarına ayırır ve piksel sayılarına göre gruplar.
İşlev, dikdörtgenin içindeki pikselleri alır ve her bir pikselin rengini hesaplar. Ardından, benzer renklere sahip olan pikselleri aynı grup içinde toplar. Gruplar, piksel sayılarına göre sıralanır ve en büyük piksel grubu öncelikli olarak seçilir.
20-Fonksiyon Çağırımı
yValueDict = YDegerleriniAl(grafik_yolu)YDegerleriniAl(grafik_yolu) çağrısı, belirtilen görüntü dizinindeki görüntülerin üzerinde belirli işlemleri gerçekleştirerek bir değer sözlüğü oluşturur. Bu değer sözlüğü, her bir görüntü için işlenmiş verileri içerir. Bu işlenmiş veriler arasında, grafiklerdeki eksenlerin belirlenmesi, etiketlerin tespiti, oranların hesaplanması ve etiket kutularının genişletilmesi ve gruplanması gibi adımlar yer alır.
Bu değer sözlüğü, görüntülerdeki veri noktalarını ve etiketleri belirleyerek, bu verilerin belirli bir düzen içinde sunulmasını sağlar.
21-Excel’e Kaydetmek
workbook = xlsxwriter.Workbook('../results/SekilVerileri.xlsx', {'nan_inf_to_errors': True})
for index, path in enumerate(Path(grafik_yolu).iterdir()):
if path.name.endswith('.png') or path.name.endswith('.jpg') or path.name.endswith('.jpeg'):
if path.name in yValueDict:
filepath = grafik_yolu + "/" + path.name
print("[{0}] path: {1}".format(index, path.name))
image = cv2.imread(filepath)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
height, width, channels = image.shape
xaxis, yaxis = eksenTespiti(filepath)
y_text = []
for (x1, y1, x2, y2) in [xaxis]:
xaxis = (x1, y1, x2, y2)
for (x1, y1, x2, y2) in [yaxis]:
yaxis = (x1, y1, x2, y2)
image_text = images_text[path.name]
image, x_labels, _, x_text, y_labels, y_labels_list, y_text_list, legends, _ = olasiEtiketleriAl(image,image_text,xaxis,yaxis)
def getYFromRect(item):
return item[1][1]
y_labels_list.sort(key = getYFromRect)
y_text_list.sort(key = getYFromRect, reverse=True)
for text, (textx, texty, w, h) in y_text_list:
y_text.append(text)
pdfname = '-'.join(path.name.split('-')[:-2]) + '.pdf'
if pdfname in doidata['Doi']:
doi = doidata['Doi'][pdfname]
else:
doi = ''
worksheet = workbook.add_worksheet()
exceleEkle("doi", doi, 0)
exceleEkle("Dosya Adı", [path.name], 1)
exceleEkle("x-text", x_text, 2)
exceleEkle("x-labels", x_labels, 3)
exceleEkle("y-text", y_text, 4)
exceleEkle("y-labels", y_labels, 5)
exceleEkle("legends", legends, 6)
data = yValueDict[path.name]
column = 9
for legend, datadict in data.items():
if column == 9:
exceleEkle("", datadict.keys(), 8)
exceleEkle(legend, datadict.values(), column)
column += 1
print("Dosya Adı : ", path.name)
print("doi : ", doi)
print("x-text : ", x_text)
print("x-labels : ", x_labels)
print("y-text : ", y_text)
print("y-labels : ", y_labels)
print("legends : ", legends)
print("data : ", data, end= "\n\n")
worksheet.insert_image('J21', filepath)
workbook.close()Bu kod bloğu, belirli bir dizindeki görüntü dosyalarını işler, bu dosyalardan çıkarılan verileri bir Excel dosyasına kaydeder ve her dosya için bir çalışma sayfası oluşturur.
İlk olarak, görüntü dosyaları Path nesnesi kullanılarak işlenir. Dosya adı uzantısına (png, jpg veya jpeg) göre kontrol edilir. Ardından, her dosya için işlem yapılır. Dosya adı, DOI (Diğer Kimliği Tanımlayıcı) ve etiketler gibi çeşitli bilgileri içeren bir Excel dosyasına kaydedilir.
Dosya adından DOI’yi almak için, dosya adının pdfname haline getirilmesi gerekmektedir. Bu işlem doidata adlı bir veri yapısı kullanılarak gerçekleştirilir. DOI bulunamazsa, ilgili hücre boş bırakılır.
Excel dosyasına yazılan diğer bilgiler arasında etiketler (x-text, x-labels, y-text, y-labels, legends) ve her etiket için ilişkili değerler yer alır.
Her dosya için bir çalışma sayfası oluşturulduktan sonra, ilgili görüntü bu sayfaya eklenir. İşlenen her bir görüntü dosyası için Excel dosyasına veri kaydetmek için kullanılır.
SONUÇ
Elde edilen görüntüler üzerindeki işlemler, verilerin analizi ve organize edilmesi adına önemli bir adımı temsil etmektedir. Bu analizler sonucunda, görüntülerdeki excel tabloların sınıflandırılması, eksenlerin belirlenmesi ve etiketlerin tespit edilmesi mümkün olmuştur. Elde edilen bu verilerin Excel çalışma kitabına aktarılması, her bir görüntünün DOI (Digital Object Identifier) değerleri ile eşleştirilmesi ve ilgili bilgilerin tablolar halinde düzenlenmesi sağlanmıştır.
Bu çalışma, görüntülerden elde edilen verilerin analizini ve organize edilmesini hedeflemekte ve başarıyla bu adımları gerçekleştirmektedir. Elde edilen veriler, DOI değerleri ile ilişkilendirilerek daha anlaşılır bir biçimde sunulmuştur. Ancak, daha ileri adımlarda bu verilerin grafiksel gösterimleri ve daha ayrıntılı istatistiksel analizleri yapılabilir. Bu şekilde elde edilen veriler, daha kapsamlı ve derinlemesine bir analize tabi tutulabilir, böylece görüntülerin içerdiği bilgiler daha ayrıntılı bir biçimde anlaşılabilir hale getirilebilir. Bu durum, elde edilen sonuçların daha kapsamlı bir biçimde yorumlanmasına olanak tanıyabilir.
+ There are no comments
Add yours