Java LuceneUtils.LUCENE_VERSION属性代码示例

/**
 * Index a picture
 * @param source
 * @param picture_id
 * @param conf
 * @throws IOException
 */
public static void index(byte[] source, UUID picture_id, IndexWriterConfig conf) throws IOException
{
    ByteArrayInputStream in = new ByteArrayInputStream(source);
    BufferedImage image = ImageIO.read(in);

    // Creating an Lucene IndexWriter
    log.debug("Is Lucene configured? " + (conf == null));
    if(conf == null) {
        conf = new IndexWriterConfig(LuceneUtils.LUCENE_VERSION, new WhitespaceAnalyzer(LuceneUtils.LUCENE_VERSION));
        conf.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);
    }

    luceneIndexer(image, picture_id, FeatureEnumerate.AutoColorCorrelogram.getText(), DocumentBuilderFactory.getAutoColorCorrelogramDocumentBuilder(), conf);
    luceneIndexer(image, picture_id, FeatureEnumerate.CEDD.getText(), DocumentBuilderFactory.getCEDDDocumentBuilder(), conf);
    luceneIndexer(image, picture_id, FeatureEnumerate.ColorLayout.getText(), DocumentBuilderFactory.getColorLayoutBuilder(), conf);
    luceneIndexer(image, picture_id, FeatureEnumerate.EdgeHistogram.getText(), DocumentBuilderFactory.getEdgeHistogramBuilder(), conf);
    luceneIndexer(image, picture_id, FeatureEnumerate.ColorHistogram.getText(), DocumentBuilderFactory.getColorHistogramDocumentBuilder(), conf);
    luceneIndexer(image, picture_id, FeatureEnumerate.PHOG.getText(), DocumentBuilderFactory.getPHOGDocumentBuilder(), conf);

}
 

private static void deleteFromFeature(UUID pictureId, Term term, String prefix, IndexWriterConfig conf) throws IOException {

        File file = getPath(prefix);

        // Creating an Lucene IndexWriter
        log.debug("Is Lucene configured: " + (conf == null));
        if(conf == null) {
            conf = new IndexWriterConfig(LuceneUtils.LUCENE_VERSION, new WhitespaceAnalyzer(LuceneUtils.LUCENE_VERSION));
            conf.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);
        }
        IndexWriter iw = new IndexWriter(FSDirectory.open(file), conf);

        iw.deleteDocuments(term);

        iw.close();
    }
 

public void run() {
        // do it ...
        try {
//            IndexWriter indexWriter = LuceneUtils.createIndexWriter(indexPath, overwriteIndex, LuceneUtils.AnalyzerType.WhitespaceAnalyzer);
            IndexWriterConfig config = new IndexWriterConfig(LuceneUtils.LUCENE_VERSION, new WhitespaceAnalyzer(LuceneUtils.LUCENE_VERSION));
            config.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);
            config.setCodec(new LireCustomCodec());
            IndexWriter indexWriter = new IndexWriter(FSDirectory.open(new File(indexPath)), config);
            for (Iterator<File> iterator = inputFiles.iterator(); iterator.hasNext(); ) {
                File inputFile = iterator.next();
                if (verbose) System.out.println("Processing " + inputFile.getPath() + ".");
                readFile(indexWriter, inputFile);
                if (verbose) System.out.println("Indexing finished.");
            }
            indexWriter.commit();
            indexWriter.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 

public void testExtendedIndexMSER() throws IOException {
    MSERDocumentBuilder builder = new MSERDocumentBuilder();
    IndexWriterConfig conf = new IndexWriterConfig(LuceneUtils.LUCENE_VERSION,
            new WhitespaceAnalyzer(LuceneUtils.LUCENE_VERSION));
    IndexWriter iw = new IndexWriter(FSDirectory.open(indexPath), conf);
    long ms = System.currentTimeMillis();
    int count = 0;
    ArrayList<File> files = FileUtils.getAllImageFiles(new File("D:\\DataSets\\WIPO\\CA\\sample"), true);
    for (Iterator<File> i = files.iterator(); i.hasNext(); ) {
        File imgFile = i.next();
        BufferedImage img = ImageIO.read(imgFile);
        if (Math.max(img.getWidth(), img.getHeight()) < 800) {
            // scale image ...
            img = ImageUtils.scaleImage(img, 800);
        }
        iw.addDocument(builder.createDocument(img, imgFile.getPath()));
        count++;
        if (count > 2 && count % 25 == 0) {
            System.out.println(count + " files indexed. " + (System.currentTimeMillis() - ms) / (count) + " ms per file");
        }

    }
    iw.close();
}
 

@PostConstruct
public void init() throws IOException {
    log.info("Creating Lucene config");

    // Creating an Lucene IndexWriter
    IndexWriterConfig conf = new IndexWriterConfig(LuceneUtils.LUCENE_VERSION,
        new WhitespaceAnalyzer(LuceneUtils.LUCENE_VERSION));
    conf.setOpenMode(IndexWriterConfig.OpenMode.CREATE_OR_APPEND);

}
 

public VisualWordsImageSearcher(int numMaxHits, Similarity similarity, String fieldName) {
    this.similarity = similarity;
    this.numMaxHits = numMaxHits;
    this.fieldName = fieldName;
    qp = new QueryParser(LuceneUtils.LUCENE_VERSION, fieldName, new WhitespaceAnalyzer(LuceneUtils.LUCENE_VERSION));
    BooleanQuery.setMaxClauseCount(10000);
}
 

public static void main(String[] args) throws IOException {
    // Checking if arg[0] is there and if it is a directory.
    boolean passed = false;
    if (args.length > 0) {
        File f = new File(args[0]);
        System.out.println("Indexing images in " + args[0]);
        if (f.exists() && f.isDirectory()) passed = true;
    }
    if (!passed) {
        System.out.println("No directory given as first argument.");
        System.out.println("Run \"Indexer <directory>\" to index files of a directory.");
        System.exit(1);
    }
    // Getting all images from a directory and its sub directories.
    ArrayList<String> images = FileUtils.getAllImages(new File(args[0]), true);

    // Creating a CEDD document builder and indexing all files.
    DocumentBuilder builder = DocumentBuilderFactory.getCEDDDocumentBuilder();
    // Creating an Lucene IndexWriter
    IndexWriterConfig conf = new IndexWriterConfig(LuceneUtils.LUCENE_VERSION,
            new WhitespaceAnalyzer(LuceneUtils.LUCENE_VERSION));
    IndexWriter iw = new IndexWriter(FSDirectory.open(new File("index")), conf);
    // Iterating through images building the low level features
    for (Iterator<String> it = images.iterator(); it.hasNext(); ) {
        String imageFilePath = it.next();
        System.out.println("Indexing " + imageFilePath);
        try {
            BufferedImage img = ImageIO.read(new FileInputStream(imageFilePath));
            Document document = builder.createDocument(img, imageFilePath);
            iw.addDocument(document);
        } catch (Exception e) {
            System.err.println("Error reading image or indexing it.");
            e.printStackTrace();
        }
    }
    // closing the IndexWriter
    iw.close();
    System.out.println("Finished indexing.");
}
 

/**
 * We assume that the initial indexing has been done and a set of reference objects has been
 * found and indexed in the separate fileList. However further documents were added and they
 * now need to get a ranked list of reference objects. So we (i) get all these new documents
 * missing the field "ro-order" and (ii) add this field.
 *
 * @param indexPath the index to update
 * @throws IOException
 */
public void updateIndex(String indexPath) throws IOException {
    IndexReader reader = DirectoryReader.open(FSDirectory.open(new File(indexPath)));
    int numDocs = reader.numDocs();
    boolean hasDeletions = reader.hasDeletions();
    int countUpdated = 0;

    IndexReader readerRo = DirectoryReader.open(FSDirectory.open(new File(indexPath + "-ro")));
    ImageSearcher searcher = new GenericImageSearcher(numReferenceObjectsUsed, featureClass, featureFieldName);
    Map<String, Analyzer> perField = new HashMap<String, Analyzer>(1);
    perField.put("ro-order", new WhitespaceAnalyzer(LuceneUtils.LUCENE_VERSION));
    PerFieldAnalyzerWrapper aWrapper =
            new PerFieldAnalyzerWrapper(new SimpleAnalyzer(LuceneUtils.LUCENE_VERSION), perField);

    IndexWriter iw = new IndexWriter(FSDirectory.open(new File(indexPath)), new IndexWriterConfig(LuceneUtils.LUCENE_VERSION, aWrapper).setOpenMode(IndexWriterConfig.OpenMode.CREATE));
    StringBuilder sb = new StringBuilder(256);
    // Needed for check whether the document is deleted.
    Bits liveDocs = MultiFields.getLiveDocs(reader);

    for (int i = 0; i < numDocs; i++) {
        if (reader.hasDeletions() && !liveDocs.get(i)) continue; // if it is deleted, just ignore it.
        Document document = reader.document(i);
        if (document.getField("ro-order") == null) {  // if the field is not here we create it.
            ImageSearchHits hits = searcher.search(document, readerRo);
            sb.delete(0, sb.length());
            for (int j = 0; j < numReferenceObjectsUsed; j++) {
                sb.append(hits.doc(j).getValues("ro-id")[0]);
                sb.append(' ');
            }
            // System.out.println(sb.toString());
            document.add(new TextField("ro-order", sb.toString(), Field.Store.YES));
            iw.updateDocument(new Term(DocumentBuilder.FIELD_NAME_IDENTIFIER, document.getValues(DocumentBuilder.FIELD_NAME_IDENTIFIER)[0]), document);
            countUpdated++;
        }

        // progress report
        progress.setNumDocsProcessed(progress.getNumDocsProcessed() + 1);

        // debug:
        System.out.println("countUpdated = " + countUpdated);
    }
    iw.commit();
    iw.close();
}