जब मैं एक एडोब रीडर पीडीएफ फाइल से कॉपी करता हूं जिसमें शामिल है
Define an operation
मैं बल्कि देखता हूं
Dene an operation
जब मैं टेक्स्ट पेस्ट करता हूं, तो यह क्यों है?
मैं इस कष्टप्रद समस्या का समाधान कैसे कर सकता हूं?
मैंने अपने प्रिंटर पर Microsoft Office Word फ़ाइल प्रिंट करते समय यह भी देखा है।
जवाबों:
यह एक फॉन्ट इश्यू की तरह लगता है। पीडीएफ शायद शब्द में ओपन टाइप fi लिगचर का उपयोग कर रहा है define, और गंतव्य एप्लिकेशन का वर्तमान फ़ॉन्ट ग्लिफ़ गायब है।
मुझे नहीं पता कि कॉपी पर लिगचर को विघटित करने के लिए एक्रोबैट प्राप्त करने का एक आसान तरीका है।
मुद्रण के साथ आपकी समस्याएं संभवतः फ़ॉन्ट-संबंधित भी हैं। कुछ संभवत: प्रिंटर अपने स्वयं के निर्मित फोंट के साथ दस्तावेज़ के फ़ॉन्ट को प्रतिस्थापित करने की अनुमति देता है और फ़ॉन्ट का प्रिंटर संस्करण भी उस विशेष ग्लिफ़ को याद नहीं कर रहा है। आपको इस समस्या के आसपास काम करने के लिए विंडोज को प्रिंटर पर हमेशा फोंट डाउनलोड करने के लिए बताना होगा।
मुद्रण करते समय एक और संभावना: UniScribe सक्षम नहीं हो सकता है। एमएस केबी 2642020 इस बारे में और कुछ संभावित वर्कअराउंड (अर्थात् ईएमएफ टाइप प्रिंटिंग के बजाय रॉ टाइप प्रिंटिंग का उपयोग करने के लिए) के बारे में बात करता है। हालांकि संदर्भ आपकी विशिष्ट समस्या से थोड़ा अलग है, कारण एक ही हो सकता है और एक ही वर्कअराउंड लागू हो सकता है।
Properties(या Preferencesडायलॉग वर्जन के आधार पर) क्लिक करें , सुनिश्चित करें कि आप Layoutया Qualityटैब पर हैं, Advancedबटन पर क्लिक करें। में Graphicसमूह, बदलने TrueType Fontके लिए विकल्प Download as Softfont। इसमें विंडोज पोस्ट-इन डायलॉग (मुझे लगता है) का उपयोग करते हुए अधिकांश पोस्टस्क्रिप्ट प्रिंटर और प्रिंटर शामिल हैं, लेकिन अन्य ड्राइवरों के पास चीजें गायब हो सकती हैं, या फ्लैट गायब हो सकते हैं।
आप इनमें से अधिकांश "टूटे हुए" शब्दों को मूल के साथ बदल सकते हैं। आप सुरक्षित रूप से एक शब्द बदल सकते हैं यदि:
deneया rey, यह एक वास्तविक शब्द नहीं हैdefineया firefly, वहाँ है एक (वैसे फिर से जोड़ संयुक्ताक्षर sequeneces को ff, fi, fl, ffi, या ffl) और एक असली शब्द बनानेअधिकांश लिगचर समस्याएं इन मानदंडों को फिट करती हैं। हालाँकि, आप प्रतिस्थापित नहीं कर सकते:
us क्योंकि यह एक वास्तविक शब्द है, भले ही यह मूल रूप से हो सकता है fluffs
affirm, butterfly, fielders, fortifies, flimflam, misfits...cusक्योंकि यह cuffsया तो बन सकता हैficus
stiffed/ stifled, rifle/ riffle, flung/ fluffing...में इस 496 हजार शब्द अंग्रेजी शब्दकोश , देखते हैं 16055 शब्द हैं जो होते हैं कम से कम एक ff, fi, fl, ffi, या fflहै, जो में बदल जाते हैं 15,879 शब्द जब उनके संयुक्ताक्षर निकाल दिए जाते हैं। 173 की तरह टकरा उन लापता शब्दों के cuffsऔर ficus, और पिछले 3 रहे हैं, क्योंकि कि शब्दकोश शब्द हैं ff, fi, और fl।
इनमें से 790 "लिगचर-हटाए गए" शब्द वास्तविक शब्द हैं, जैसे us, लेकिन 15089 टूटे हुए शब्द हैं। टूटे हुए शब्दों में से 14960 को मूल शब्द से सुरक्षित रूप से प्रतिस्थापित किया जा सकता है, जिसका अर्थ है कि टूटे हुए शब्दों में से 99.1% निश्चित हैं और 93.2% मूल शब्द जिनमें पीडीएफ को कॉपी-पेस्ट करने के बाद एक लिगचर को पुनर्प्राप्त किया जा सकता है। ९ ६% लिगचर अनुक्रम वाले शब्द टकरावों ( cus) और उप-शब्दों ( us), तब तक खो जाते हैं , जब तक कि आप प्रत्येक शब्द के लिए सबसे अच्छा प्रतिस्थापन चुनने के लिए कोई रास्ता नहीं निकालते (शब्द / दस्तावेज़ संदर्भ?), जिनके पास गारंटी नहीं है। प्रतिस्थापन।
नीचे मेरी पायथन लिपि है जो उपरोक्त आँकड़े उत्पन्न करती है। यह प्रति पंक्ति एक शब्द के साथ एक शब्दकोश पाठ फ़ाइल की अपेक्षा करता है। अंत में यह एक CSV फ़ाइल लिखता है जो अपने मूल शब्दों के लिए टूटे हुए शब्दों को मैप करता है।
यहाँ CSV डाउनलोड करने के लिए एक लिंक दिया गया है: http://www.filedropper.com/brokenligaturewordfixes इस मैपिंग को एक रेगीक्स रिप्लेसमेंट स्क्रिप्ट की तरह कुछ के साथ मिलाएं ताकि अधिकतर टूटे हुए शब्दों को बदला जा सके।
import csv
import itertools
import operator
import re
dictionary_file_path = 'dictionary.txt'
broken_word_fixes_file_path = 'broken_word_fixes.csv'
ligatures = 'ffi', 'ffl', 'ff', 'fi', 'fl'
with open(dictionary_file_path, 'r') as dictionary_file:
dictionary_words = list(set(line.strip()
for line in dictionary_file.readlines()))
broken_word_fixes = {}
ligature_words = set()
ligature_removed_words = set()
broken_words = set()
multi_ligature_words = set()
# Find broken word fixes for words with one ligature sequence
# Example: "dene" --> "define"
words_and_ligatures = list(itertools.product(dictionary_words, ligatures))
for i, (word, ligature) in enumerate(words_and_ligatures):
if i % 50000 == 0:
print('1-ligature words {percent:.3g}% complete'
.format(percent=100 * i / len(words_and_ligatures)))
for ligature_match in re.finditer(ligature, word):
if word in ligature_words:
multi_ligature_words.add(word)
ligature_words.add(word)
if word == ligature:
break
# Skip words that contain a larger ligature
if (('ffi' in word and ligature != 'ffi') or
('ffl' in word and ligature != 'ffl')):
break
# Replace ligatures with dots to avoid creating new ligatures
# Example: "offline" --> "of.ine" to avoid creating "fi"
ligature_removed_word = (word[:ligature_match.start()] +
'.' +
word[ligature_match.end():])
# Skip words that contain another ligature
if any(ligature in ligature_removed_word for ligature in ligatures):
continue
ligature_removed_word = ligature_removed_word.replace('.', '')
ligature_removed_words.add(ligature_removed_word)
if ligature_removed_word not in dictionary_words:
broken_word = ligature_removed_word
broken_words.add(broken_word)
if broken_word not in broken_word_fixes:
broken_word_fixes[broken_word] = word
else:
# Ignore broken words with multiple possible fixes
# Example: "cus" --> "cuffs" or "ficus"
broken_word_fixes[broken_word] = None
# Find broken word fixes for word with multiple ligature sequences
# Example: "rey" --> "firefly"
multi_ligature_words = sorted(multi_ligature_words)
numbers_of_ligatures_in_word = 2, 3
for number_of_ligatures_in_word in numbers_of_ligatures_in_word:
ligature_lists = itertools.combinations_with_replacement(
ligatures, r=number_of_ligatures_in_word
)
words_and_ligature_lists = list(itertools.product(
multi_ligature_words, ligature_lists
))
for i, (word, ligature_list) in enumerate(words_and_ligature_lists):
if i % 1000 == 0:
print('{n}-ligature words {percent:.3g}% complete'
.format(n=number_of_ligatures_in_word,
percent=100 * i / len(words_and_ligature_lists)))
# Skip words that contain a larger ligature
if (('ffi' in word and 'ffi' not in ligature_list) or
('ffl' in word and 'ffl' not in ligature_list)):
continue
ligature_removed_word = word
for ligature in ligature_list:
ligature_matches = list(re.finditer(ligature, ligature_removed_word))
if not ligature_matches:
break
ligature_match = ligature_matches[0]
# Replace ligatures with dots to avoid creating new ligatures
# Example: "offline" --> "of.ine" to avoid creating "fi"
ligature_removed_word = (
ligature_removed_word[:ligature_match.start()] +
'.' +
ligature_removed_word[ligature_match.end():]
)
else:
# Skip words that contain another ligature
if any(ligature in ligature_removed_word for ligature in ligatures):
continue
ligature_removed_word = ligature_removed_word.replace('.', '')
ligature_removed_words.add(ligature_removed_word)
if ligature_removed_word not in dictionary_words:
broken_word = ligature_removed_word
broken_words.add(broken_word)
if broken_word not in broken_word_fixes:
broken_word_fixes[broken_word] = word
else:
# Ignore broken words with multiple possible fixes
# Example: "ung" --> "flung" or "fluffing"
broken_word_fixes[broken_word] = None
# Remove broken words with multiple possible fixes
for broken_word, fixed_word in broken_word_fixes.copy().items():
if not fixed_word:
broken_word_fixes.pop(broken_word)
number_of_ligature_words = len(ligature_words)
number_of_ligature_removed_words = len(ligature_removed_words)
number_of_broken_words = len(broken_words)
number_of_fixable_broken_words = len(
[word for word in set(broken_word_fixes.keys())
if word and broken_word_fixes[word]]
)
number_of_recoverable_ligature_words = len(
[word for word in set(broken_word_fixes.values())
if word]
)
print(number_of_ligature_words, 'ligature words')
print(number_of_ligature_removed_words, 'ligature-removed words')
print(number_of_broken_words, 'broken words')
print(number_of_fixable_broken_words,
'fixable broken words ({percent:.3g}% fixable)'
.format(percent=(
100 * number_of_fixable_broken_words / number_of_broken_words
)))
print(number_of_recoverable_ligature_words,
'recoverable ligature words ({percent:.3g}% recoverable)'
'(for at least one broken word)'
.format(percent=(
100 * number_of_recoverable_ligature_words / number_of_ligature_words
)))
with open(broken_word_fixes_file_path, 'w+', newline='') as broken_word_fixes_file:
csv_writer = csv.writer(broken_word_fixes_file)
sorted_broken_word_fixes = sorted(broken_word_fixes.items(),
key=operator.itemgetter(0))
for broken_word, fixed_word in sorted_broken_word_fixes:
csv_writer.writerow([broken_word, fixed_word])
.csvटूट गया है। यह बहुत अच्छा होगा अगर आप इसे फिर से अपलोड कर सकें! किसी भी मामले में, कोड के लिए धन्यवाद।
इस मुद्दे पर, अन्य जवाब नोटों के रूप में है, ligatures के साथ। हालाँकि, इसका OpenType से कोई लेना-देना नहीं है। मूलभूत समस्या यह है कि PDF एक प्री-प्रिंट प्रारूप है, जो केवल सामग्री और शब्दार्थ के साथ बहुत कम चिंता करता है, लेकिन इसके बजाय एक पृष्ठ का ईमानदारी से प्रतिनिधित्व करते हुए इसे प्रिंट किया जाएगा।
पाठ को पाठ के रूप में नहीं बल्कि कुछ पदों पर एक फ़ॉन्ट से ग्लिफ़ के रूप में निर्धारित किया जाता है । तो आपको कुछ ऐसा मिलता है जैसे »ग्लिफ़ नंबर 72 वहां, ग्लिफ़ नंबर 101 वहाँ, ग्लिफ़ नंबर 108 वहाँ, ...«। उस स्तर पर मौलिक रूप से पाठ का बोध भी नहीं है सब पर । यह सिर्फ एक विवरण है कि यह कैसा दिखता है । ग्लिफ़ के एक गुच्छा से अर्थ निकालने में दो समस्याएं हैं:
स्थानिक लेआउट। चूँकि PDF में पहले से ही विशिष्ट जानकारी होती है, जहाँ प्रत्येक ग्लिफ़ को रखने के लिए सामान्य रूप से अंतर्निहित कोई वास्तविक पाठ नहीं होता है। एक और दुष्प्रभाव यह है कि कोई स्थान नहीं है। ज़रूर, अगर आप पाठ को देखते हैं, लेकिन पीडीएफ में नहीं हैं। खाली ग्लिफ़ का उत्सर्जन क्यों करें जब आप सिर्फ किसी को भी उत्सर्जित कर सकते हैं? परिणाम वही है, सब के बाद। इसलिए पीडीएफ पाठकों को ध्यान से पाठ को फिर से एक साथ जोड़ना है, जब भी वे ग्लिफ़ के बीच एक बड़ा अंतर रखते हैं, तो एक जगह डालते हैं।
पीडीएफ ग्लिफ का प्रतिपादन करता है, पाठ का नहीं। अधिकांश समय ग्लिफ़ आईडी यूनिकोड कोड पॉइंट्स या कम से कम ASCII कोड्स के साथ एम्बेडेड फोंट में मेल खाती है, जिसका अर्थ है कि आप अक्सर ASCII या लैटिन 1 पाठ को अच्छी तरह से वापस पा सकते हैं, जो इस बात पर निर्भर करता है कि पहली बार में पीडीएफ किसने बनाया था (कुछ प्रक्रिया में सब कुछ गार्बेल )। लेकिन अक्सर यहां तक कि पीडीएफ जो आपको एएससीआईआई पाठ से बाहर निकलने की अनुमति देते हैं, ठीक है वह सब कुछ जो एएससीआईआई नहीं है, को नियंत्रित करेगा । विशेष रूप से अरबी जैसे जटिल लिपियों के साथ भयानक जो केवल लेआउट के बाद लिगचर और वैकल्पिक ग्लिफ़ होते हैं, जिसका अर्थ है कि अरबी पीडीएफ में लगभग कभी वास्तविक पाठ नहीं होता है
दूसरी समस्या आपके सामने आने जैसी है। यहां एक आम अपराधी लाटेक्स है जो अपने उत्पादन को प्राप्त करने के लिए अनुमानित संख्या 238982375 विभिन्न फोंट (जिनमें से प्रत्येक 256 ग्लिफ़ तक सीमित है) का उपयोग करता है। सामान्य पाठ, गणित (एक से अधिक का उपयोग करता है), आदि के लिए अलग-अलग फोंट बहुत मुश्किल काम करते हैं, विशेष रूप से मेटाफ़ॉन्ट लगभग दो दशकों तक यूनिकोड से पहले की तरह है और इस तरह कभी भी एक यूनिकोड मानचित्रण नहीं था। Umlauts को एक पत्र पर आरोपित किए गए एक डाइरेसिस द्वारा भी प्रस्तुत किया जाता है, उदाहरण के लिए एक पीडीएफ से कॉपी करते समय »ä» के बजाय »area« मिलता है (और निश्चित रूप से इसके लिए खोज भी नहीं कर सकता है)।
पीडीएफ बनाने वाले एप्लिकेशन वास्तविक पाठ को मेटाडेटा के रूप में शामिल करने का विकल्प चुन सकते हैं। यदि वे नहीं करते हैं, तो आप इस दया पर छोड़ देते हैं कि एम्बेडेड फ़ॉन्ट कैसे संभाला जाता है और क्या पीडीएफ रीडर फिर से मूल पाठ को एक साथ जोड़ सकता है। लेकिन »फाई« को रिक्त के रूप में कॉपी किया जा रहा है या नहीं, आमतौर पर एक LaTeX पीडीएफ का संकेत है। आपको यूनिकोड के चरित्रों को पत्थरों पर चित्रित करना चाहिए और उन्हें निर्माता पर फेंकना चाहिए, उम्मीद है कि वे XeLaTeX पर स्विच करेंगे और इस प्रकार 1990 के अंत में चरित्र एन्कोडिंग और फ़ॉन्ट मानकों पर पहुंचेंगे।