/*************************************************************************** kocrstartdia.cpp - description ------------------- begin : Fri Now 10 2000 copyright : (C) 2000 by Klaas Freitag email : freitag@suse.de ***************************************************************************/ /*************************************************************************** * * * This file may be distributed and/or modified under the terms of the * * GNU General Public License version 2 as published by the Free Software * * Foundation and appearing in the file COPYING included in the * * packaging of this file. * * * As a special exception, permission is given to link this program * * with any version of the KADMOS ocr/icr engine of reRecognition GmbH, * * Kreuzlingen and distribute the resulting executable without * * including the source code for KADMOS in the source distribution. * * * As a special exception, permission is given to link this program * * with any edition of TQt, and distribute the resulting executable, * * without including the source code for TQt in the source distribution. * * * ***************************************************************************/ #include <tqlayout.h> #include <tqlabel.h> #include <tqfileinfo.h> #include <tqtooltip.h> #include <tqvbox.h> #include <tqdict.h> #include <tqdir.h> #include <tqmap.h> #include <tqbuttongroup.h> #include <tqradiobutton.h> #include <kapplication.h> #include <kconfig.h> #include <kglobal.h> #include <kdebug.h> #include <klocale.h> #include <kanimwidget.h> #include <kseparator.h> #include <kmessagebox.h> #include "resource.h" #include "ksaneocr.h" // TODO: Really needed? #include "kocrkadmos.h" #include "kocrkadmos.moc" #include <kscanslider.h> #include <tqcheckbox.h> #include <kstandarddirs.h> #include <tqstringlist.h> /* defines for konfig-reading */ #define CFG_GROUP_KADMOS "Kadmos" #define CFG_KADMOS_CLASSIFIER_PATH "classifierPath" #define CFG_KADMOS_CLASSIFIER "classifier" #define CNTRY_CZ i18n( "Czech Republic, Slovakia") #define CNTRY_GB i18n( "Great Britain, USA" ) KadmosDialog::KadmosDialog( TQWidget *parent, KSpellConfig *spellConfig ) :KOCRBase( parent, spellConfig, KDialogBase::Tabbed ), m_cbNoise(0), m_cbAutoscale(0), m_haveNorm(false) { kdDebug(28000) << "Starting KOCR-Start-Dialog!" << endl; // Layout-Boxes findClassifiers(); } TQString KadmosDialog::ocrEngineLogo() const { return "kadmoslogo.png"; } TQString KadmosDialog::ocrEngineName() const { return i18n("KADMOS OCR/ICR"); } TQString KadmosDialog::ocrEngineDesc() const { return i18n("This version of Kooka was linked with the <I>KADMOS OCR/ICR engine</I>, a " "commercial engine for optical character recognition.<P>" "Kadmos is a product of <B>re Recognition AG</B><BR>" "For more information about Kadmos OCR see " "<A HREF=http://www.rerecognition.com>" "http://www.rerecognition.com</A>"); } EngineError KadmosDialog::findClassifiers() { findClassifierPath(); KLocale *locale = KGlobal::locale(); TQStringList allCountries = locale->allLanguagesTwoAlpha (); for ( TQStringList::Iterator it = allCountries.begin(); it != allCountries.end(); ++it ) { m_longCountry2short[locale->twoAlphaToCountryName(*it)] = *it; } m_longCountry2short[i18n("European Countries")] = "eu"; m_longCountry2short[ CNTRY_CZ ] = "cz"; m_longCountry2short[ CNTRY_GB ] = "us"; TQStringList lst; /* custom Path */ if( ! m_customClassifierPath.isEmpty() ) { TQDir dir( m_customClassifierPath ); TQStringList lst1 = dir.entryList( "ttf*.rec" ); for ( TQStringList::Iterator it = lst1.begin(); it != lst1.end(); ++it ) { lst << m_customClassifierPath + *it; } lst1 = dir.entryList( "hand*.rec" ); for ( TQStringList::Iterator it = lst1.begin(); it != lst1.end(); ++it ) { lst << m_customClassifierPath + *it; } lst1 = dir.entryList( "norm*.rec" ); for ( TQStringList::Iterator it = lst1.begin(); it != lst1.end(); ++it ) { lst << m_customClassifierPath + *it; } } else { /* standard location */ KStandardDirs stdDir; kdDebug(28000) << "Starting to read resource" << endl; lst = stdDir.findAllResources( "data", "kooka/classifiers/*.rec", true, /* recursive */ true ); /* uniqu */ } /* no go through lst and sort out hand-, ttf- and norm classifier */ for ( TQStringList::Iterator it = lst.begin(); it != lst.end(); ++it ) { TQFileInfo fi( *it); TQString name = fi.fileName().lower(); kdDebug(28000) << "Checking file " << *it << endl; if( name.startsWith( "ttf" ) ) { TQString lang = name.mid(3,2); if( allCountries.contains(lang) ) { TQString lngCountry = locale->twoAlphaToCountryName(lang); if( lngCountry.isEmpty() ) lngCountry = name; m_ttfClassifier << lngCountry; kdDebug(28000) << "ttf: Insert country " << lngCountry << endl; } else if( lang == "cz" ) { m_ttfClassifier << CNTRY_CZ; } else if( lang == "us" ) { m_ttfClassifier << CNTRY_GB; } else { m_ttfClassifier << name; kdDebug(28000) << "ttf: Unknown country" << endl; } } else if( name.startsWith( "hand" ) ) { TQString lang = name.mid(4,2); if( allCountries.contains(lang) ) { TQString lngCountry = locale->twoAlphaToCountryName(lang); if( lngCountry.isEmpty() ) lngCountry = name; m_handClassifier << lngCountry; } else if( lang == "cz" ) { m_handClassifier << i18n( "Czech Republic, Slovakia"); } else if( lang == "us" ) { m_handClassifier << i18n( "Great Britain, USA" ); } else { kdDebug(28000) << "Hand: Unknown country " << lang << endl; m_handClassifier << name; } } else if( name.startsWith( "norm" )) { m_haveNorm = true; } kdDebug(28000) << "Found classifier: " << *it << endl; m_classifierPath << *it; } if( m_handClassifier.count()+m_ttfClassifier.count()>0 ) { /* There are classifiers */ return ENG_OK; } else { /* Classifier are missing */ return ENG_DATA_MISSING; } } EngineError KadmosDialog::findClassifierPath() { KStandardDirs stdDir; EngineError err = ENG_OK; KConfig *conf = KGlobal::config (); KConfigGroupSaver gs( conf, CFG_GROUP_KADMOS ); m_customClassifierPath = conf->readPathEntry( CFG_KADMOS_CLASSIFIER_PATH ); #if 0 if( m_customClassifierPath == "NotFound" ) { /* Wants the classifiers from the standard kde paths */ KMessageBox::error(0, i18n("The classifier files for KADMOS could not be found.\n" "OCR with KADMOS will not be possible!\n\n" "Change the OCR engine in the preferences dialog."), i18n("Installation Error") ); } else { m_classifierPath = customPath; } #endif return err; } EngineError KadmosDialog::setupGui() { EngineError err = KOCRBase::setupGui(); // setupPreprocessing( addVBoxPage( i18n("Preprocessing"))); // setupSegmentation( addVBoxPage( i18n("Segmentation"))); // setupClassification( addVBoxPage( i18n("Classification"))); /* continue page setup on the first page */ TQVBox *page = ocrPage(); //Qt::Horizontal line (void) new KSeparator( KSeparator::HLine, page); // FIXME: dynamic classifier reading. (void) new TQLabel( i18n("Please classify the font type and language of the text on the image:"), page ); TQHBox *locBox = new TQHBox( page ); m_bbFont = new TQButtonGroup(1, Qt::Horizontal, i18n("Font Type Selection"), locBox); m_rbMachine = new TQRadioButton( i18n("Machine print"), m_bbFont ); m_rbHand = new TQRadioButton( i18n("Hand writing"), m_bbFont ); m_rbNorm = new TQRadioButton( i18n("Norm font"), m_bbFont ); m_gbLang = new TQGroupBox(1, Qt::Horizontal, i18n("Country"), locBox); m_cbLang = new TQComboBox( m_gbLang ); m_cbLang->setCurrentText( KLocale::defaultCountry() ); connect( m_bbFont, TQT_SIGNAL(clicked(int)), this, TQT_SLOT(slFontChanged(int) )); m_rbMachine->setChecked(true); /* --- */ TQHBox *innerBox = new TQHBox( page ); innerBox->setSpacing( KDialog::spacingHint()); TQButtonGroup *cbGroup = new TQButtonGroup( 1, Qt::Horizontal, i18n("OCR Modifier"), innerBox ); Q_CHECK_PTR(cbGroup); m_cbNoise = new TQCheckBox( i18n( "Enable automatic noise reduction" ), cbGroup ); m_cbAutoscale = new TQCheckBox( i18n( "Enable automatic scaling"), cbGroup ); getAnimation(innerBox); // (void) new TQWidget ( page ); if( err != ENG_OK ) { enableFields(false); enableButton(User1, false ); } if( m_ttfClassifier.count() == 0 ) { m_rbMachine->setEnabled(false); } if( m_handClassifier.count() == 0 ) { m_rbHand->setEnabled(false); } if( !m_haveNorm ) m_rbNorm->setEnabled(false); if( (m_ttfClassifier.count() + m_handClassifier.count()) == 0 && ! m_haveNorm ) { KMessageBox::error(0, i18n("The classifier files for KADMOS could not be found.\n" "OCR with KADMOS will not be possible!\n\n" "Change the OCR engine in the preferences dialog."), i18n("Installation Error") ); err = ENG_BAD_SETUP; } else slFontChanged( 0 ); // Load machine print font language list return err; } void KadmosDialog::slFontChanged( int id ) { m_cbLang->clear(); KConfig *conf = KGlobal::config (); KConfigGroupSaver gs( conf, CFG_GROUP_KADMOS ); m_customClassifierPath = conf->readPathEntry( CFG_KADMOS_CLASSIFIER_PATH ); bool enable = true; if( id == 0 ) /* Machine Print */ { m_cbLang->insertStringList( m_ttfClassifier ); } else if( id == 1 ) /* Hand Writing */ { m_cbLang->insertStringList( m_handClassifier ); } else if( id == 2 ) /* Norm Font */ { enable = false; } m_cbLang->setEnabled( enable ); } void KadmosDialog::setupPreprocessing( TQVBox* ) { } void KadmosDialog::setupSegmentation( TQVBox* ) { } void KadmosDialog::setupClassification( TQVBox* ) { } /* * returns the complete path of the classifier selected in the * GUI in the parameter path. The result value indicates if there * was one found. */ bool KadmosDialog::getSelClassifier( TQString& path ) const { TQString classifier = getSelClassifierName(); TQString cmplPath; /* * Search the complete path for the classifier file name * returned from the getSelClassifierName method */ for ( TQStringList::ConstIterator it = m_classifierPath.begin(); it != m_classifierPath.end(); ++it ) { TQFileInfo fi( *it ); if( fi.fileName() == classifier ) { cmplPath = *it; break; } } bool res = true; if( cmplPath.isEmpty() ) { /* hm, no path was found */ kdDebug(28000) << "ERR; The entire path is empty, joking?" << endl; res = false; } else { /* Check if the classifier exists on the HD. If not, return an empty string */ TQFileInfo fi(cmplPath); if( res && ! fi.exists() ) { kdDebug(28000) << "Classifier file does not exist" << endl; path = i18n("Classifier file %1 does not exist").tqarg(classifier); res = false; } if( res && ! fi.isReadable() ) { kdDebug(28000) << "Classifier file could not be read" << endl; path = i18n("Classifier file %1 is not readable").tqarg(classifier); res = false; } if( res ) path = cmplPath; } return res; } TQString KadmosDialog::getSelClassifierName() const { TQButton *butt = m_bbFont->selected(); TQString fType, rType; if( butt ) { int fontTypeID = m_bbFont->id(butt); if( fontTypeID == 0 ) fType = "ttf"; else if( fontTypeID == 1 ) fType = "hand"; else if( fontTypeID == 2 ) fType = "norm"; else kdDebug(28000) << "ERR: Wrong Font Type ID" << endl; } /* Get the long text from the combo box */ TQString selLang = m_cbLang->currentText(); TQString trans; if( fType != "norm" && m_longCountry2short.contains( selLang )) { TQString langType = m_longCountry2short[selLang]; trans = fType+langType+".rec"; } else { if( selLang.endsWith( ".rec" )) { /* can be a undetected */ trans = selLang; } else if( fType == "norm" ) { trans = "norm.rec"; } else kdDebug(28000) << "ERROR: Not a valid classifier" << endl; } kdDebug(28000) << "Returning trans. "<< trans << endl; return( trans ); } bool KadmosDialog::getAutoScale() { return( m_cbAutoscale ? m_cbAutoscale->isChecked() : false ); } bool KadmosDialog::getNoiseReduction() { return( m_cbNoise ? m_cbNoise->isChecked() : false ); } KadmosDialog::~KadmosDialog() { } void KadmosDialog::writeConfig( void ) { } void KadmosDialog::enableFields( bool state ) { kdDebug(28000) << "About to disable the entry fields" << endl; m_cbNoise->setEnabled( state ); m_cbAutoscale->setEnabled( state ); m_bbFont->setEnabled( state ); m_gbLang->setEnabled( state ); } /* The End ;) */