Search Java Classes and Packages

Search Java Frameworks and Libraries

255581 classes and counting ...
Search Tips Index Status

# Classes and Interfaces in #Processing - 2245 results found.
AbstractBottomUpParserAbstract class which contains code to tag and chunk parses for bottom up parsing and leaves implementation of advancing parses and completing parses to extend Language Processing (OpenNLP)
AbstractContextGeneratorAbstract class containing many of the methods used to generate contexts for Language Processing (OpenNLP)
AbstractDataIndexerAbstract class for collecting event and context counts used in Language Processing (OpenNLP)
AbstractEndOfSentenceScannerAbstract class for common methods related to identifying potential ends of Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
AbstractParserEventStreamAbstract class extended by parser event streams which perform tagging and Language Processing (OpenNLP)
AbstractSampleStreamFactoryBase class for sample stream Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
AdaptiveFeatureGeneratorAn interface for generating features for name entity identification and for updating document level Language Processing (OpenNLP)
ADChunkSampleStreamParser for Floresta Sita(c)tica Arvores Deitadas corpus, output to for the Portuguese Chunker Language Processing (OpenNLP)
ADChunkSampleStreamFactoryA Factory to create a Arvores Deitadas ChunkStream from the command line Note: Do not use this class, internal use only! Language Processing (OpenNLP)
AdditionalContextFeatureGeneratorThe AdditionalContextFeatureGenerator generates the context from the passed in additional Language Processing (OpenNLP)
ADNameSampleStreamParser for Floresta Sita(c)tica Arvores Deitadas corpus, output to for the Portuguese NER Language Processing (OpenNLP)
ADNameSampleStreamFactoryA Factory to create a Arvores Deitadas NameSampleDataStream from the command line Note: Do not use this class, internal use only! Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
ADSentenceStreamStream filter which merges text lines into sentences, following the Arvores Information about the Language Processing (OpenNLP) Language Processing (OpenNLP)
AggregatedFeatureGeneratorThe AggregatedFeatureGenerator aggregates a set of AdaptiveFeatureGenerators and calls them to generate the Language Processing (OpenNLP)
AncoraSpanishHeadRulesClass for storing the Ancora Spanish head rules associated with Language Processing (OpenNLP) Language Processing (OpenNLP)
ArrayMathUtility class for simple vector Language Processing (OpenNLP)
ArtifactProviderProvides access to model persisted Language Processing (OpenNLP)
ArtifactSerializerResponsible to create an artifact from an Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
AttributesThe Attributes class stores name value Language Processing (OpenNLP)
BagOfWordsFeatureGeneratorGenerates a feature for each word in a Language Processing (OpenNLP)
BaseLinkStores a minimal tuple of Language Processing (OpenNLP)
BaseModelThis model is a common based which can be used by the components Provide sub classes access to serializers already in Language Processing (OpenNLP)
BaseToolFactoryBase class for all tool Language Processing (OpenNLP)
BasicContextGeneratorGenerate contexts for maxent decisions, assuming that the input given to the getContext() method is a String containing Language Processing (OpenNLP)
BeamSearchPerforms k-best search over Language Processing (OpenNLP)
BeamSearchPerforms k-best search over Language Processing (OpenNLP)
BeamSearchContextGeneratorInterface for context generators used with a sequence beam Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
BinaryGISModelReaderA reader for GIS models stored in binary Language Processing (OpenNLP)
BinaryGISModelWriterModel writer that saves models in binary Language Processing (OpenNLP) Language Processing (OpenNLP)
BinaryPerceptronModelWriterModel writer that saves models in binary Language Processing (OpenNLP)
BinaryQNModelReaderA reader for quasi-newton models stored in binary Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
BioNLP2004NameSampleStreamParser for the training files of the BioNLP/NLPBA 2004 shared Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
BratAnnotationStreamReads the annotations from the brat Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
BratNameSampleStreamGenerates Name Sample objects for a Brat Document Language Processing (OpenNLP) Language Processing (OpenNLP)
BrownBigramFeatureGeneratorGenerates Brown cluster features for token Language Processing (OpenNLP)
BrownClusterClass to load a Brown cluster document: word\tword_class\tprob Language Processing (OpenNLP)
BrownTokenClassesObtain the paths listed in the pathLengths array from the Brown Language Processing (OpenNLP)
BrownTokenClassFeatureGeneratorGenerates Brown cluster features for current token and token Language Processing (OpenNLP)
BrownTokenFeatureGeneratorGenerates Brown cluster features for current Language Processing (OpenNLP)
BuildContextGeneratorClass to generator predictive contexts for deciding how constituents should be combined Language Processing (OpenNLP)
BuildContextGeneratorCreates the features or contexts for the building phase of Language Processing (OpenNLP)
CacheProvides fixed size, pre-allocated, least recently used replacement Language Processing (OpenNLP)
CachedFeatureGeneratorCaches features of the aggregated Language Processing (OpenNLP)
CharacterNgramFeatureGeneratorThe CharacterNgramFeatureGenerator uses character ngrams to generate features about each Language Processing (OpenNLP)
CheckContextGeneratorClass for generating predictive context for deciding when a constituent is Language Processing (OpenNLP) Language Processing (OpenNLP)
ChunkContextGeneratorCreates predivtive context for the pre-chunking phases of Language Processing (OpenNLP)
ChunkerThe interface for chunkers which provide chunk tags for a sequence of Language Processing (OpenNLP)
ChunkerContextGeneratorInterface for the context generator used in syntactic Language Processing (OpenNLP) Language Processing (OpenNLP)
ChunkerEvaluatorThe ChunkerEvaluator measures the performance of the given Chunker with the Language Processing (OpenNLP)
ChunkerEventStreamClass for creating an event stream out of data files for training a Language Processing (OpenNLP) Language Processing (OpenNLP)
ChunkerMEThe class represents a maximum-entropy-based Language Processing (OpenNLP)
ChunkerModelThe ChunkerModel is the model used by a learnable Language Processing (OpenNLP)
ChunkerSampleStreamFactoryFactory producing OpenNLP Language Processing (OpenNLP)
ChunkSampleClass for holding chunks for a single unit of Language Processing (OpenNLP) Language Processing (OpenNLP)
ChunkSampleStreamParses the conll 2000 shared task shallow parser training Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
ComparableEventA maxent event representation which we can use to sort based on the predicates indexes contained in the Language Processing (OpenNLP)
ComparablePredicateA maxent predicate representation which we can use to sort based on the Language Processing (OpenNLP)
Conll02NameSampleStreamParser for the dutch and spanish ner training files of the CONLL 2002 shared Language Processing (OpenNLP) Language Processing (OpenNLP)
Conll03NameSampleStreamAn import stream which can parse the CONLL03 Language Processing (OpenNLP) Language Processing (OpenNLP)
ConllXPOSSampleStreamParses the data from the CONLL 06 shared task into POS Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
ConsClass to hold feature information about a specific parse Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
ConstituentClass used to hold constituents when reading Language Processing (OpenNLP)
ContextClass which associates a real valued parameter or expected value with a particular contextual predicate or Language Processing (OpenNLP)
ContextGeneratorGenerate contexts for maxent Language Processing (OpenNLP)
CountedSetSet which counts the number of times a values are added to Language Processing (OpenNLP)
CrossValidationPartitionerProvides access to training and test partitions for n-fold cross Language Processing (OpenNLP) Language Processing (OpenNLP)
DataIndexerObject which compresses events in memory and performs feature Language Processing (OpenNLP) Language Processing (OpenNLP)
DataStreamA interface for objects which can deliver a stream of training data to be supplied to an Language Processing (OpenNLP)
DefaultChunkerContextGeneratorFeatures based on chunking model described in Fei Sha and Fernando Language Processing (OpenNLP) Language Processing (OpenNLP)
DefaultEndOfSentenceScannerDefault implementation of the Language Processing (OpenNLP)
DefaultNameContextGeneratorClass for determining contextual features for a tag/chunk style named-entity Language Processing (OpenNLP)
DefaultPOSContextGeneratorA context generator for the POS Language Processing (OpenNLP) Language Processing (OpenNLP)
DefaultSDContextGeneratorGenerate event contexts for maxent decisions for sentence Language Processing (OpenNLP)
DefaultTokenContextGeneratorGenerate events for maxent decisions for Language Processing (OpenNLP) Language Processing (OpenNLP)
DetokenizerA Detokenizer merges tokens back to their untokenized Language Processing (OpenNLP)
DetokenizerSampleStreamFactoryBase class for factories which need Language Processing (OpenNLP)
DictionaryThis class is a Language Processing (OpenNLP)
DictionaryDetokenizerA rule based Language Processing (OpenNLP)
DictionaryFeatureGeneratorThe DictionaryFeatureGenerator uses the DictionaryNameFinder to generated features for detected names based on the Language Processing (OpenNLP) Language Processing (OpenNLP)
DictionaryNameFinderThis is a dictionary based name finder, it scans text for names inside a Language Processing (OpenNLP)
DictionarySerializerThis class is used by for reading and writing dictionaries of all Language Processing (OpenNLP)
DirectorySampleStreamThe directory sample stream scans a directory (recursively) for plain text files and outputs each file as a String Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
DocumentCategorizerInterface for classes which categorize Language Processing (OpenNLP)
DocumentCategorizerEvaluatorThe DocumentCategorizerEvaluator measures the performance of the given DocumentCategorizer with the provided Language Processing (OpenNLP)
DocumentCategorizerEventStreamIterator-like class for modeling document classification Language Processing (OpenNLP)
DocumentCategorizerMEMaxent implementation of Language Processing (OpenNLP)
DocumentNameFinderName finding interface which processes an entire document allowing the name finder to use context from the entire Language Processing (OpenNLP)
DocumentSampleClass which holds a classified document and its Language Processing (OpenNLP)
DocumentSampleStreamThis class reads in string encoded training samples, parses them and outputs DocumentSample Language Processing (OpenNLP)
DocumentSampleStreamFactoryFactory producing OpenNLP Language Processing (OpenNLP)
DocumentToLineStreamReads a plain text file and return each line as a String Language Processing (OpenNLP) Language Processing (OpenNLP)
EmptyLinePreprocessorStreamStream to to clean up empty lines for empty line separated document Language Processing (OpenNLP)
EndOfSentenceScannerScans Strings, StringBuffers, and char[] arrays for the offsets of sentence ending Language Processing (OpenNLP)
EntityLinkerEntityLinkers establish connections to external data to enrich extracted Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
EntryAn Entry is a StringList which can optionally be mapped to Language Processing (OpenNLP) Language Processing (OpenNLP)
EvalitaNameSampleStreamParser for the Italian NER training files of the Evalita 2007 and 2009 NER shared Language Processing (OpenNLP) Language Processing (OpenNLP)
EvalParametersThis class encapsulates the varibales used in producing probabilities from a model and facilitaes passing these variables to the eval Language Processing (OpenNLP) Language Processing (OpenNLP)
EvaluatorThe Evaluator is an abstract base class for Language Processing (OpenNLP)
EventThe context of a decision point during Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
ExtensionLoaderThe ExtensionLoader is responsible to load extensions to the OpenNLP Language Processing (OpenNLP)
ExtensionNotLoadedExceptionException indicates that an OpenNLP extension could not be Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
FastTokenClassFeatureGeneratorGenerates features for different for the class of the Language Processing (OpenNLP)
FeatureGeneratorInterface for generating features for document Language Processing (OpenNLP)
FeatureGeneratorAdapterThis class provides empty implementations of some of the optional methods in AdditionalContextFeatureGenerator to make implementing feature Language Processing (OpenNLP)
FeatureGeneratorFactoryThe FeatureGeneratorFactory interface is factory for Language Processing (OpenNLP) Language Processing (OpenNLP)
FeatureGeneratorResourceProviderThe FeatureGeneratorResourceProvider provides access to the resources provided in the Language Processing (OpenNLP)
FeatureGeneratorUtilThis class provide common utilities for feature Language Processing (OpenNLP)
FileEventStreamClass for using a file of events as an event Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
FilterObjectStreamAbstract base class for filtering Language Processing (OpenNLP)
FMeasureThe FMeasure is an utility class for evaluators which measure precision, recall and the resulting Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
GeneratorFactoryCreates a set of feature generators based on a provided XML Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
GISModelA maximum entropy model which has been trained using the Generalized Iterative Scaling procedure (implemented in Language Processing (OpenNLP)
GISModelReaderAbstract parent class for readers of Language Processing (OpenNLP)
GISModelWriterAbstract parent class for GISModel Language Processing (OpenNLP)
HashListClass which creates mapping between keys and a list of Language Processing (OpenNLP) Language Processing (OpenNLP)
HeadRulesInterface for encoding the head rules associated with Language Processing (OpenNLP)
HeadRulesClass for storing the English head rules associated with Language Processing (OpenNLP)
HeapInterface for interacting with a Heap data Language Processing (OpenNLP)
IndexThis classes indexes Language Processing (OpenNLP)
IndexHashTableThe IndexHashTable is a hash table which maps entries of an array to their index in the Language Processing (OpenNLP)
InputStreamFactoryAllows repeated reads through a stream for certain types of model Language Processing (OpenNLP) Language Processing (OpenNLP)
IntegerPoolA pool of read-only, unsigned Integer objects within a fixed, non-sparse Language Processing (OpenNLP)
InvalidFormatExceptionThis exception indicates that a resource violates the expected data Language Processing (OpenNLP)
LanguageSampleStreamFactoryStream factory for those streams which carry Language Processing (OpenNLP)
LeipzigDoccatSampleStreamStream filter to produce document samples out of a Leipzig Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
ListHeapThis class implements the heap interface using a List as the underlying data Language Processing (OpenNLP) Language Processing (OpenNLP)
MaxentModelInterface for maximum entropy Language Processing (OpenNLP)
MeanCalculates the arithmetic mean of values added with the add(double) Language Processing (OpenNLP) Language Processing (OpenNLP)
ModelUtilUtility class for handling of Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
MutableContextClass used to store parameters or expected values associated with this context which can be updated or Language Processing (OpenNLP)
MutableTagDictionaryInterface that allows TagDictionary entries to be added and Language Processing (OpenNLP)
NameContextGeneratorInterface for generating the context for an name finder by specifying a set of geature Language Processing (OpenNLP)
NameFinderCensus90NameStreamThis class helps to read the US Census data from the files to build a StringList for each dictionary entry in the name-finder Language Processing (OpenNLP) Language Processing (OpenNLP)
NameFinderMEClass for creating a maximum-entropy-based name Language Processing (OpenNLP) Language Processing (OpenNLP)
NameSampleClass for holding names for a single unit of Language Processing (OpenNLP)
NameSampleDataStreamThe NameSampleDataStream class converts tagged Strings provided by a DataStream to NameSample Language Processing (OpenNLP)
NameSampleDataStreamFactoryFactory producing OpenNLP Language Processing (OpenNLP) Language Processing (OpenNLP)
NameSampleTypeFilterA stream which removes Name Samples which do not have a certain Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
NegLogLikelihoodEvaluate negative log-likelihood and its gradient from Language Processing (OpenNLP)
NewlineSentenceDetectorThe Newline Sentence Detector assumes that sentences are line delimited and recognizes one sentence per non-empty Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
NGramModelThe NGramModel can be used to crate ngrams and character Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
ObjectStreamReads Objects from a Language Processing (OpenNLP) Language Processing (OpenNLP)
OldFormatGISModelReaderA reader for GIS models stored in the format used in Language Processing (OpenNLP)
OnePassDataIndexerAn indexer for maxent model data which handles cutoffs for uncommon contextual predicates and provides a unique integer index for each of Language Processing (OpenNLP)
OnePassRealValueDataIndexerAn indexer for maxent model data which handles cutoffs for uncommon contextual predicates and provides a unique integer index for each of Language Processing (OpenNLP)
OntoNotesNameSampleStreamName Sample Stream parser for the OntoNotes Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
OSGiExtensionLoaderOSGi bundle activator which can use an OSGi service as an OpenNLP Language Processing (OpenNLP)
OutcomePriorFeatureGeneratorThe definition feature maps the underlying distribution of Language Processing (OpenNLP)
ParagraphStreamStream filter which merges text lines into Language Processing (OpenNLP) Language Processing (OpenNLP)
ParseData structure for holding parse Language Processing (OpenNLP)
ParserClass for a shift reduce style parser based on Adwait Ratnaparkhi's 1998 Language Processing (OpenNLP)
ParserInterface for full-syntactic Language Processing (OpenNLP)
ParserBuilt/attach Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
ParserEvaluatorClass for Language Processing (OpenNLP)
ParserEventStreamWrapper class for one of four parser event Language Processing (OpenNLP) Language Processing (OpenNLP)
ParserEventTypeEnumenum ParserEventTypeEnumEnumerated type of event types for the Language Processing (OpenNLP) Language Processing (OpenNLP)
ParserModelThis is an abstract base class for ParserModel Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
ParseSampleStreamFactoryFactory producing OpenNLP Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
PerceptronModelReaderAbstract parent class for readers of Language Processing (OpenNLP)
PerceptronModelWriterAbstract parent class for Perceptron Language Processing (OpenNLP)
PerceptronTrainerTrains models using the perceptron Language Processing (OpenNLP)
PlainTextByLineStreamReads a plain text file and return each line as a String Language Processing (OpenNLP) Language Processing (OpenNLP)
PlainTextGISModelReaderA reader for GIS models stored in plain text Language Processing (OpenNLP)
PlainTextGISModelWriterModel writer that saves models in plain text Language Processing (OpenNLP) Language Processing (OpenNLP)
PlainTextPerceptronModelWriterModel writer that saves models in plain text Language Processing (OpenNLP)
PooledGISModelReaderThis class works exactly like the SuffisSensitiveGISModelReader except that it attempts to pool all context Language Processing (OpenNLP)
PorterStemmerStemmer, implementing the Porter Stemming Algorithm The Stemmer class transforms a word into its root Language Processing (OpenNLP)
PortugueseContractionUtilityUtility class to handle Portuguese Language Processing (OpenNLP)
POSContextGeneratorThe interface for a context generator for the POS Language Processing (OpenNLP)
POSDictionaryProvides a means of determining which tags are valid for a particular word based on a tag dictionary read from a Language Processing (OpenNLP)
POSDictionaryWriterClass for writing a pos-tag-dictionary to a Language Processing (OpenNLP)
POSEvaluatorThe POSEvaluator measures the performance of the given POSTagger with the provided Language Processing (OpenNLP)
POSModelThe POSModel is the model used by a learnable Language Processing (OpenNLP)
POSSampleRepresents an pos-tagged Language Processing (OpenNLP)
POSSampleEventStreamThis class reads the POSSamples from the given Iterator and converts the POSSamples into Events Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
POSTaggerThe interface for part of speech Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
POSTaggerMEA part-of-speech tagger that uses maximum Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
PreviousMapFeatureGeneratorThis FeatureGeneratorAdapter generates features indicating the outcome associated with a previously occuring Language Processing (OpenNLP)
PreviousTwoMapFeatureGeneratorThis FeatureGeneratorAdapter generates features indicating the outcome associated with two previously occuring Language Processing (OpenNLP)
PriorThis interface allows one to implement a prior distribution for use in maximum entropy model Language Processing (OpenNLP)
QNMinimizer and Elastic Net for solving convex optimization Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
QNTrainerMaxent model trainer using L-BFGS Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
RegexNameFinderName finder based on a series of regular Language Processing (OpenNLP)
RegexNameFinderFactoryReturns a RegexNameFinder based on A selection of defaults or a configuration and a selection of Language Processing (OpenNLP) Language Processing (OpenNLP)
ResetableIteratorThis interface makes an Iterator Language Processing (OpenNLP)
ReverseListIteratorAn iterator for a list which returns values in the opposite order as the typical list Language Processing (OpenNLP)
SDContextGeneratorInterface for SentenceDetectorME context Language Processing (OpenNLP)
SDCrossValidatorA cross validator for the sentence Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
SentenceContextGeneratorCreates contexts/features for end-of-sentence detection in Thai Language Processing (OpenNLP) Language Processing (OpenNLP)
SentenceDetectorEvaluatorThe SentenceDetectorEvaluator measures the performance of the given SentenceDetector with the provided Language Processing (OpenNLP) Language Processing (OpenNLP)
SentenceDetectorMEA sentence detector for splitting up raw text into Language Processing (OpenNLP)
SentenceFeatureGeneratorThis feature generator creates sentence begin and end Language Processing (OpenNLP)
SentenceModelThe SentenceModel is the model used by a learnable Language Processing (OpenNLP)
SentenceSampleA SentenceSample contains a document with begin indexes of the individual Language Processing (OpenNLP)
SentenceSampleStreamThis class is a stream filter which reads a sentence by line samples from a Reader and converts them into SentenceSample Language Processing (OpenNLP)
SentenceSampleStreamFactoryFactory producing OpenNLP Language Processing (OpenNLP)
SequenceClass which models a Language Processing (OpenNLP)
SequenceRepresents a weighted sequence of Language Processing (OpenNLP)
SequenceClassificationModelA classification model that can label an input Language Processing (OpenNLP) Language Processing (OpenNLP)
SequenceStreamInterface for streams of sequences used to train sequence Language Processing (OpenNLP)
SequenceStreamEventStreamClass which turns a sequence stream into an event Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
SgmlParserSAX style SGML Language Processing (OpenNLP) Language Processing (OpenNLP)
SimplePerceptronSequenceTrainerTrains models for sequences using the perceptron Language Processing (OpenNLP)
SimpleTokenizerPerforms tokenization using character Language Processing (OpenNLP) Language Processing (OpenNLP)
SpanClass for storing start and end integer Language Processing (OpenNLP) Language Processing (OpenNLP)
StringListThe StringList is an immutable list of Language Processing (OpenNLP)
StringPatternRecognizes predefined patterns in Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
SuffixSensitiveGISModelReaderA reader for GIS models which inspects the filename and invokes the appropriate GISModelReader depending on the filename's Language Processing (OpenNLP)
SuffixSensitiveGISModelWriterA writer for GIS models which inspects the filename and invokes the appropriate GISModelWriter depending on the filename's Language Processing (OpenNLP)
SuffixSensitivePerceptronModelWriterA writer for GIS models which inspects the filename and invokes the appropriate GISModelWriter depending on the filename's Language Processing (OpenNLP)
TagDictionaryInterface to determine which tags are valid for a particular word based on a tag Language Processing (OpenNLP)
TokenClassFeatureGeneratorGenerates features for different for the class of the Language Processing (OpenNLP)
TokenContextGeneratorInterface for TokenizerME context Language Processing (OpenNLP)
TokenFeatureGeneratorGenerates a feature which contains the token Language Processing (OpenNLP)
TokenizerThe interface for tokenizers, which segment a string into its Language Processing (OpenNLP) Language Processing (OpenNLP)
TokenizerEvaluatorThe TokenizerEvaluator measures the performance of the given Tokenizer with the provided Language Processing (OpenNLP)
TokenizerFactoryThe factory that provides Tokenizer default implementations and Language Processing (OpenNLP)
TokenizerMEA Tokenizer for converting raw text into separated Language Processing (OpenNLP)
TokenizerModelThe TokenizerModel is the model used by a learnable Language Processing (OpenNLP)
TokenizerStreamThe TokenizerStream uses a tokenizer to tokenize the input string and output Language Processing (OpenNLP)
TokenNameFinderThe interface for name finders which provide name tags for a sequence of Language Processing (OpenNLP) Language Processing (OpenNLP)
TokenNameFinderEvaluatorThe TokenNameFinderEvaluator measures the performance of the given TokenNameFinder with the Language Processing (OpenNLP) Language Processing (OpenNLP)
TokenNameFinderModelThe TokenNameFinderModel is the model used by a learnable Language Processing (OpenNLP)
TokenPatternFeatureGeneratorPartitions tokens into sub-tokens based on character classes and generates class features for each of the sub-tokens and combinations of those Language Processing (OpenNLP)
TokenSampleA TokenSample is text with token Language Processing (OpenNLP)
TokenSampleStreamClass which produces an Iterator from a file of space delimited Language Processing (OpenNLP)
TokenSampleStreamThis class is a stream filter which reads in string encoded samples and creates TokenSamples out of Language Processing (OpenNLP)
TokenSampleStreamFactoryFactory producing OpenNLP Language Processing (OpenNLP)
TokSpanEventStreamThis class reads the TokenSamples from the given Iterator and converts the TokenSamples into Events Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
TreeHeapAn implementation of the Heap interface based on Language Processing (OpenNLP)
TrigramNameFeatureGeneratorAdds trigram features based on tokens and token Language Processing (OpenNLP)
TwoPassDataIndexerCollecting event and context counts by making two passes over the Language Processing (OpenNLP)
UncloseableInputStreamAn InputStream which cannot be Language Processing (OpenNLP)
UniformPriorProvide a maximum entropy model with a uniform Language Processing (OpenNLP)
VersionThe Version class represents the OpenNlp Tools library Language Processing (OpenNLP)
WhitespaceTokenizerThis tokenizer uses white spaces to tokenize the input Language Processing (OpenNLP)
WhitespaceTokenStreamThis stream formats a TokenSamples into whitespace separated token Language Processing (OpenNLP)
WindowFeatureGeneratorGenerates previous and next features for a given Language Processing (OpenNLP) Language Processing (OpenNLP) Language Processing (OpenNLP)
WordTagSampleStreamA stream filter which reads a sentence per line which contains words and tags in word_tag format and outputs a POSSample Language Processing (OpenNLP) Language Processing (OpenNLP)
AbstractModelResourceClassopennlp.uima.utilNatural Language Processing (OpenNLP)
AbstractSentenceDetectorClassopennlp.uima.sentdetectNatural Language Processing (OpenNLP)
AbstractTokenizerClassopennlp.uima.tokenizeNatural Language Processing (OpenNLP)
AnnotationComboIteratorUIMA Annotation iterator combination of super- and subiterator.Classopennlp.uima.utilNatural Language Processing (OpenNLP)
AnnotationComparatorChecks two annotations for equality.Classopennlp.uima.utilNatural Language Processing (OpenNLP)
AnnotationIteratorPairA pair of a UIMA annotation and an annotation iterator.Classopennlp.uima.utilNatural Language Processing (OpenNLP)
AnnotatorUtilThis is a utility class for Annotators.Classopennlp.uima.utilNatural Language Processing (OpenNLP)
CasConsumerUtilThis is a util class for cas consumer.Classopennlp.uima.utilNatural Language Processing (OpenNLP)
ChunkerOpenNLP Chunker annotator.Classopennlp.uima.chunkerNatural Language Processing (OpenNLP)
ChunkerModelResourceImplClassopennlp.uima.chunkerNatural Language Processing (OpenNLP)
ChunkerTrainerOpenNLP Chunker trainer.Classopennlp.uima.chunkerNatural Language Processing (OpenNLP)
ContainingConstraintChecks if an AnnotationFS is contained by the given AnnotationFS.Classopennlp.uima.utilNatural Language Processing (OpenNLP)
DictionaryNameFinderClassopennlp.uima.namefindNatural Language Processing (OpenNLP)
DoccatModelResourceImplClassopennlp.uima.doccatNatural Language Processing (OpenNLP)
DocumentCategorizerOpenNLP Document Categorizer.Classopennlp.uima.doccatNatural Language Processing (OpenNLP)
DocumentCategorizerTrainerOpenNLP NameFinder trainer.Classopennlp.uima.doccatNatural Language Processing (OpenNLP)
ExceptionMessagesClassopennlp.uima.utilNatural Language Processing (OpenNLP)
LanguageDetectorAnalysis Engine which can detected the language of a text.Classopennlp.uima.doccatNatural Language Processing (OpenNLP)
NameFinderOpenNLP Name annotator.Classopennlp.uima.namefindNatural Language Processing (OpenNLP)
NameFinderTrainerOpenNLP NameFinder trainer.Classopennlp.uima.namefindNatural Language Processing (OpenNLP)
NormalizerThe Normalizer tries the structure annotations.Classopennlp.uima.normalizerNatural Language Processing (OpenNLP)
NumberUtilThis class contains methods to parse numbers which occur in natural language texts.Classopennlp.uima.normalizerNatural Language Processing (OpenNLP)
OpenNlpAnnotatorProcessExceptionClassopennlp.uima.utilNatural Language Processing (OpenNLP)
OpennlpUtilThis class contains utils methods for the maxent library.Classopennlp.uima.utilNatural Language Processing (OpenNLP)
ParserAbstract base class for OpenNLP Parser annotators.Classopennlp.uima.parserNatural Language Processing (OpenNLP)
ParserModelResourceImplClassopennlp.uima.parserNatural Language Processing (OpenNLP)
POSModelResourceImplClassopennlp.uima.postagNatural Language Processing (OpenNLP)
POSTaggerOpenNLP Part Of Speech annotator.Classopennlp.uima.postagNatural Language Processing (OpenNLP)
POSTaggerTrainerOpenNLP POSTagger trainer.Classopennlp.uima.postagNatural Language Processing (OpenNLP)
SampleTraceStreamWrites the samples which are processed by this stream to a file.Classopennlp.uima.utilNatural Language Processing (OpenNLP)
SentenceDetectorOpenNLP Sentence annotator.Classopennlp.uima.sentdetectNatural Language Processing (OpenNLP)
SentenceDetectorTrainerOpenNLP SentenceDetector trainer.Classopennlp.uima.sentdetectNatural Language Processing (OpenNLP)
SentenceModelResourceImplClassopennlp.uima.sentdetectNatural Language Processing (OpenNLP)
SimpleTokenizerOpenNLP Simple Tokenizer annotator.Classopennlp.uima.tokenizeNatural Language Processing (OpenNLP)
StringDictionaryClassopennlp.uima.normalizerNatural Language Processing (OpenNLP)
TokenizerOpenNLP Tokenizer annotator.Classopennlp.uima.tokenizeNatural Language Processing (OpenNLP)
TokenizerModelResourceA TokenizerModel which can be shared between AnalysisEngines and loaded via the UIMA resource model.Interfaceopennlp.uima.tokenizeNatural Language Processing (OpenNLP)
TokenizerModelResourceImplClassopennlp.uima.tokenizeNatural Language Processing (OpenNLP)
TokenizerTrainerOpenNLP Tokenizer trainer.Classopennlp.uima.tokenizeNatural Language Processing (OpenNLP)
TokenNameFinderModelResourceInterfaceopennlp.uima.namefindNatural Language Processing (OpenNLP)
TokenNameFinderModelResourceImplClassopennlp.uima.namefindNatural Language Processing (OpenNLP)
UimaUtilThis is a util class for uima operations.Classopennlp.uima.utilNatural Language Processing (OpenNLP)
WhitespaceTokenizerOpenNLP Whitespace Tokenizer annotator.Classopennlp.uima.tokenizeNatural Language Processing (OpenNLP)
AbstractCollinsHeadFinderA base class for a HeadFinder similar to the one described in Michael Collins' 1999 thesis.Classedu.stanford.nlp.treesJavaNlp
AbstractDependencyGrammarAn abstract base class for dependency grammars.Classedu.stanford.nlp.parser.lexparserJavaNlp
AbstractEvalA framework for Set-based precision/recall/F1 evaluation.Classedu.stanford.nlp.parser.metricsJavaNlp
AbstractIteratorIterator with remove() defined to throw an UnsupportedOperationException.Classedu.stanford.nlp.utilJavaNlp
AbstractLinearClassifierFactoryShared methods for training a LinearClassifier.Classedu.stanford.nlp.classifyJavaNlp
AbstractSequenceClassifierThis class provides common functionality for (probabilistic) sequence models.Classedu.stanford.nlp.ieJavaNlp
AbstractStochasticCachingDiffUpdateFunctionFunction for stochastic calculations that does update in place (instead of maintaining and returning the derivative).Classedu.stanford.nlp.optimizationJavaNlp
AbstractTextAnnotationCreatorCreates a stub implementation for creating annotation from various input sources using String as the main input sourceClassedu.stanford.nlp.pipelineJavaNlp
AbstractTokenizerAn abstract tokenizer.Classedu.stanford.nlp.processJavaNlp
AbstractTreebankLanguagePackThis provides an implementation of parts of the TreebankLanguagePack API to reduce the load on fresh implementations.Classedu.stanford.nlp.treesJavaNlp
AbstractTreebankParserParamsAn abstract class providing a common method base from which to complete a TreebankLangParserParams implementing class.Classedu.stanford.nlp.parser.lexparserJavaNlp
AbstractTreeExtractorAn abstract superclass for parser classes that extract counts from Trees.Classedu.stanford.nlp.parser.lexparserJavaNlp
AccuracyStatsUtility class for aggregating counts of true positives, false positives, and false negatives and computing precision/recall/F1 stats.Classedu.stanford.nlp.statsJavaNlp
AceDomReaderDOM reader for an ACE
AceElementBase class for all ACE annotation
ACEMentionExtractorExtracts mentions from a file annotated in ACE format (ACE2004, ACE2005).Classedu.stanford.nlp.dcorefJavaNlp
AceReaderSimple wrapper of Mihai's ACE code to
AcronymMatcherA simple class with a variety of acronym matching utilities.Classedu.stanford.nlp.utilJavaNlp
AdaptedGaussianPriorObjectiveFunctionAdapt the mean of the Gaussian Prior by shifting the mean to the previously trained weightsAuthor:Pi-Chuan Chang, Sarah Spikes (sdspikes@cs.Classedu.stanford.nlp.classifyJavaNlp
ADMathThe class ADMath was created to extend the current calculations of gradient to automatically include a calculation of theClassedu.stanford.nlp.mathJavaNlp
affDictaffixation informationAuthor:Huihsin Tseng, Pichuan ChangClassedu.stanford.nlp.wordsegJavaNlp
AlignmentRepresents an alignment between a text and a hypothesis as a map from hypothesis words to text words, along with a real-valued score andClassedu.stanford.nlp.semgraph.semgrexJavaNlp
AmbiguityClassAn ambiguity class for a word is the word by itself or its set of observed tags.Classedu.stanford.nlp.tagger.maxentJavaNlp
AmbiguityClassesA collection of Ambiguity Class.Classedu.stanford.nlp.tagger.maxentJavaNlp
AmericanizeTakes a HasWord or String and returns an Americanized version of it.Classedu.stanford.nlp.processJavaNlp
AnCoraPronounDisambiguatorA utility for preprocessing the AnCora Spanish
AnnotatedTextReaderCanNOT handle overlapping labeled text (that is one token cannot belong to multiple labels)! Note that there has to be spaces around the tags Classedu.stanford.nlp.patterns.surfaceJavaNlp
AnnotationAn annotation representing a span of text in a document.Classedu.stanford.nlp.pipelineJavaNlp
AnnotationOutputterAn interface for outputting CoreNLP Annotations to different output These are intended to be for more or less human consumption (or for transferringClassedu.stanford.nlp.pipelineJavaNlp
AnnotationPipelineThis class is designed to apply multiple Annotators to an Annotation.Classedu.stanford.nlp.pipelineJavaNlp
AnnotatorThis is an interface for adding annotations to a partially annotated Annotation.Interfaceedu.stanford.nlp.pipelineJavaNlp
AnnotatorFactoriesA companion to AnnotatorFactory defining the common annotators.Classedu.stanford.nlp.pipelineJavaNlp
AnnotatorFactoryA Factory for creating a certain type of Annotator.Classedu.stanford.nlp.pipelineJavaNlp
AnnotatorImplementationsA class abstracting the implementation of various annotators.Classedu.stanford.nlp.pipelineJavaNlp
AnnotatorPoolAn object for keeping track of Annotators.Classedu.stanford.nlp.pipelineJavaNlp
ApplyDepPatternsApplying Dependency patterns to sentences.Classedu.stanford.nlp.patterns.depJavaNlp
ApplyPatternsApplying SurfacePattern to sentences.Classedu.stanford.nlp.patterns.surfaceJavaNlp
ArabicDocumentReaderAndWriterReads newline delimited UTF-8 Arabic sentences with or without gold segmentation
ArabicHeadFinderFind the head of an Arabic tree, using the usual kind of heuristic head finding
ArabicMorphoFeatureSpecificationExtracts morphosyntactic features from BAMA/SAMA
ArabicSegmenterArabic word segmentation model based on conditional random fields (CRF)
ArabicSegmenterFeatureFactoryFeature factory for the IOB clitic segmentation model described by Green and DeNero (2012)
ArabicTokenizerTokenizer for UTF-8
ArabicTreebankLanguagePackSpecifies the treebank/language specific components needed for parsing the Penn Arabic Treebank (ATB)
ArabicTreebankParserParamsA TreebankLangParserParams implementing class for the Penn Arabic Treebank.Classedu.stanford.nlp.parser.lexparserJavaNlp
ArabicTreebankTokenizerBuilds a tokenizer for the Penn Arabic Treebank (ATB) using a This implementation is current as of the following LDC catalog numbers:
ArabicTreeNormalizerNormalizes both terminals and non-terminals in Penn Arabic Treebank (ATB)
ArabicTreeReaderFactoryReads ArabicTreebank
ArabicUnknownWordModelThis is a basic unknown word model for Arabic.Classedu.stanford.nlp.parser.lexparserJavaNlp
ArgUtilsUtility methods or common blocks of code for dealing with parser arguments, such as extracting Treebank informationClassedu.stanford.nlp.parser.commonJavaNlp
ArrayCoreMap Base implementation of CoreMap backed by two Java arrays.Classedu.stanford.nlp.utilJavaNlp
ArrayHeap Values are all implicit in the comparator passed in on construction.Classedu.stanford.nlp.utilJavaNlp
ArrayMapMap backed by an Array.Classedu.stanford.nlp.utilJavaNlp
ArraySetAn array-backed set.Classedu.stanford.nlp.utilJavaNlp
ArrayStringFilterFilters Strings based on whether they exactly match any string in the array it is initially constructed with.Classedu.stanford.nlp.utilJavaNlp
ArrayUtilsStatic utility methods for operating on arrays.Classedu.stanford.nlp.utilJavaNlp
AssignableExpressionThis interface represents an expression that can be assigned to.Interfaceedu.stanford.nlp.ling.tokensregex.typesJavaNlp
ATBArabicDatasetConverts raw ATB trees into a format appropriate for treebank
ATBCorrectorMakes ATB trees consistent with
ATBCorrectorVisitorWrapper class for using the ATBCorrector class with TreebankPipeline's TVISITOR
ATBTreeUtilsVarious static convenience methods for processing Arabic parse
BaseLexiconThis is the default concrete instantiation of the Lexicon interface.Classedu.stanford.nlp.parser.lexparserJavaNlp
BaseUnknownWordModelAn unknown word model for a generic language.Classedu.stanford.nlp.parser.lexparserJavaNlp
BasicCategoryTreeTransformerTransforms trees by turning the labels into their basic categories TreebankLanguagePackClassedu.stanford.nlp.treesJavaNlp
BasicDatumBasic implementation of Datum interface that can be constructed with a Collection of features and one more more labels.Classedu.stanford.nlp.lingJavaNlp
BasicDocumentBasic implementation of Document that should be suitable for most needs.Classedu.stanford.nlp.lingJavaNlp
BasicEntityExtractorUses parsed files to train classifier and test on data
Beam ScoredComparator.Classedu.stanford.nlp.utilJavaNlp
BeamBestSequenceFinderA class capable of computing the best sequence given a SequenceModel.Classedu.stanford.nlp.sequencesJavaNlp
BestOfTopKEvalApplies an AbstractEval to a list of trees to pick the best tree using F1 measure.Classedu.stanford.nlp.parser.metricsJavaNlp
BestSequenceFinderAn interface for classes capable of computing the best sequence given Or it turns out that some implementations don't actually find the bestInterfaceedu.stanford.nlp.sequencesJavaNlp
BiasedLogConditionalObjectiveFunctionMaximizes the conditional likelihood with a given prior.Classedu.stanford.nlp.classifyJavaNlp
BikelChineseHeadFinderA headfinder implementing Dan Bikel's head
BiLexPCFGParser PCFG parsing.Classedu.stanford.nlp.parser.lexparserJavaNlp
BinarizerAnnotatorThis annotator takes unbinarized trees (from the parser annotator or elsewhere) and binarizes them in the attachment.Classedu.stanford.nlp.pipelineJavaNlp
BinaryGrammarMaintains efficient indexing of binary grammar rules.Classedu.stanford.nlp.parser.lexparserJavaNlp
BinaryHeapPriorityQueuePriorityQueue with explicit double priority values.Classedu.stanford.nlp.utilJavaNlp
BinaryRuleBinary rules (ints for parent, left and right children)Author:Dan Klein, Christopher ManningSee Also:Serialized FormClassedu.stanford.nlp.parser.lexparserJavaNlp
BinaryTransitionTransition that makes a binary parse node in a partially finished tree.Classedu.stanford.nlp.parser.shiftreduceJavaNlp
BobChrisTreeNormalizerNormalizes trees in the way used in Manning and Carpenter 1997.Classedu.stanford.nlp.treesJavaNlp
BoundaryRemoverRemoves a boundary symbol (Lexicon.Classedu.stanford.nlp.parser.lexparserJavaNlp
BoundedCostOrderedMapMap that is sorted by cost - keep lowest scores When deciding what item to keep with the same cost, ties are arbitrarily brokenClassedu.stanford.nlp.ling.tokensregex.matcherJavaNlp
BuckwalterThis class can convert between Unicode and Buckwalter encodings of "MORPHOLOGICAL ANALYSIS & POS ANNOTATION,"
ByteStreamGobblerStream Gobbler that read and write bytes (can be used to gobble byte based stdout from a process.Classedu.stanford.nlp.utilJavaNlp
BZip2PipedOutputStreamOpens a outputstream for writing into a bzip2 file by piping into the bzip2 command.Classedu.stanford.nlp.ioJavaNlp
CacheMapA fixed size hash map with LRU replacement.Classedu.stanford.nlp.utilJavaNlp
CallbackFunctionA callback function (along the lines of Berkeley optimization repo), which is currently used in the optimization package.Classedu.stanford.nlp.utilJavaNlp
CandidatePhraseCreated by Sonal Gupta on 11/7/14.Classedu.stanford.nlp.patternsJavaNlp
CategoryWordTagA CategoryWordTag object acts as a complex Label which contains a category, a head word, and a tag.Classedu.stanford.nlp.lingJavaNlp
CategoryWordTagFactoryA CategoryWordTagFactory is a factory that makes a Label which is a CategoryWordTag triplet.Classedu.stanford.nlp.lingJavaNlp
CGMinimizerConjugate-gradient implementation based on the code in Numerical Recipes in C.Classedu.stanford.nlp.optimizationJavaNlp
CGRunnerThis class will call an optimization method such as Conjugate Gradient or Quasi-Newton on a LambdaSolve object to findClassedu.stanford.nlp.maxentJavaNlp
CharactersCharacter-level utilities.Classedu.stanford.nlp.utilJavaNlp
CharniakParserAnnotatorThis class will add parse information to an Annotation from the BLLIP parser.Classedu.stanford.nlp.pipelineJavaNlp
ChineseCollinizerPerforms collinization operations on Chinese trees similar to those for English Namely: strips all functional & automatically-added
ChineseDictionaryThis class provides a main method that loads various dictionaries, and saves them in a serialized version, and runtime compiles them into a word list used as a feature in the segmenter.Classedu.stanford.nlp.wordsegJavaNlp
ChineseDocumentToSentenceProcessorConvert a Chinese Document into a List of sentence Strings.Classedu.stanford.nlp.processJavaNlp
ChineseEnglishWordMapA class for mapping Chinese words to
ChineseEscaperAn Escaper for Chinese normalization to match
ChineseGrammaticalRelationsChineseGrammaticalRelations is a set of GrammaticalRelation objects for the Chinese
ChineseGrammaticalStructureA GrammaticalStructure for
ChineseHeadFinderHeadFinder for the Penn Chinese
ChineseLexiconA lexicon class for Chinese.Classedu.stanford.nlp.parser.lexparserJavaNlp
ChineseLexiconAndWordSegmenterThis class lets you train a lexicon and segmenter at the same time.Classedu.stanford.nlp.parser.lexparserJavaNlp
ChineseMarkovWordSegmenterPerforms word segmentation with a hierarchical markov model over POS and over characters given POS.Classedu.stanford.nlp.parser.lexparserJavaNlp
ChineseSegmenterAnnotatorThis class will add segmentation information to an Annotation.Classedu.stanford.nlp.pipelineJavaNlp
ChineseSegmenterFeatureFactoryA Chinese segmenter Feature Factory for GALE project.Classedu.stanford.nlp.wordsegJavaNlp
ChineseSimWordAvgDepGrammarA Dependency grammar that smooths by averaging over similar words.Classedu.stanford.nlp.parser.lexparserJavaNlp
ChineseTreebankLanguagePackLanguage pack for the UPenn/Colorado Chinese
ChineseTreebankParserParamsParameter file for parsing the Penn Chinese Treebank.Classedu.stanford.nlp.parser.lexparserJavaNlp
ChineseUnknownWordModelStores, trains, and scores with an unknown word model.Classedu.stanford.nlp.parser.lexparserJavaNlp
ChineseUtilsThis class contains a few String constants and static methods for dealing with Chinese
CHTBTokenizerA simple tokenizer for tokenizing Penn Chinese Treebank
ClassicCounterA specialized kind of hash table (or map) for storing numeric counts for objects.Classedu.stanford.nlp.statsJavaNlp
ClassifierA simple interface for classifying and scoring data points, implemented by most of the classifiers in this package.Interfaceedu.stanford.nlp.classifyJavaNlp
ClassifierNeural network classifier which powers a transition-based dependency This classifier is built to accept distributed-representationClassedu.stanford.nlp.parser.nndepJavaNlp
ClassifierCombinerMerges the outputs of two or more AbstractSequenceClassifiers according to a simple precedence scheme: any given base classifier contributes onlyClassedu.stanford.nlp.ieJavaNlp
ClassifierExampleSample code that illustrates the training and use of a linear classifier.Classedu.stanford.nlp.classifyJavaNlp
ClassifierFactoryA simple interface for training a Classifier from a Dataset of training Templatized by Sarah Spikes (sdspikes@cs.Interfaceedu.stanford.nlp.classifyJavaNlp
ClauseSplitterJust a convenience alias for a clause splitting search problem factory.Interfaceedu.stanford.nlp.naturalliJavaNlp
ClauseSplitterSearchProblem A search problem for finding clauses in a sentence.Classedu.stanford.nlp.naturalliJavaNlp
CleanXmlAnnotatorAn annotator which removes all XML tags (as identified by the tokenizer) and possibly selectively keeps the text between them.Classedu.stanford.nlp.pipelineJavaNlp
CliqueThis class is meant to represent a clique in a (directed or undirected) linear-chain graphical model.Classedu.stanford.nlp.sequencesJavaNlp
CMMClassifierDoes Sequence Classification using a Conditional Markov
CollapseUnaryTransformerThis transformer collapses chains of unary nodes so that the top node is the only node left.Classedu.stanford.nlp.sentimentJavaNlp
CollectionFactoryFactory for vending Collections.Classedu.stanford.nlp.utilJavaNlp
CollectionUtilsCollection of useful static methods for working with Collections.Classedu.stanford.nlp.utilJavaNlp
CollectionValuedMapMap from keys to Collections.Classedu.stanford.nlp.utilJavaNlp
CollinsHeadFinder Except: we've added a head rule for NX, which returns the leftmost item.Classedu.stanford.nlp.treesJavaNlp
CollinsPuncTransformerThis class manipulates punctuation in trees (used with training trees) in the same manner that Collins manipulated punctuation in trees whenClassedu.stanford.nlp.parser.lexparserJavaNlp
CollocationFinderFinds WordNet collocations in parse trees.Classedu.stanford.nlp.treesJavaNlp
ColorANSI supported colors These values are mirrored in Redwood.Classedu.stanford.nlp.util.loggingJavaNlp
ColumnDataClassifierColumnDataClassifier provides a command-line interface for doing context-free (independent) classification of a series of data items,Classedu.stanford.nlp.classifyJavaNlp
ColumnDataClassifierAnnotatorCreated by joberant on 9/8/14.Classedu.stanford.nlp.pipelineJavaNlp
ColumnDocumentReaderAndWriterDocumentReader for column format.Classedu.stanford.nlp.sequencesJavaNlp
CombinationFeatureFactoryCombines multiple feature factories into one feature factoryAuthor:John BauerSee Also:Serialized FormClassedu.stanford.nlp.parser.shiftreduceJavaNlp
ComplexNodePatternPattern for matching a complex data structureAuthor:Angel ChangSee Also:Serialized FormClassedu.stanford.nlp.ling.tokensregexJavaNlp
CompositeTreeTransformerA TreeTransformer that applies component TreeTransformers in order.Classedu.stanford.nlp.treesJavaNlp
CompoundUnaryTransitionTransition that makes a compound unary parse node in a partially finished tree.Classedu.stanford.nlp.parser.shiftreduceJavaNlp
ConcatenationIteratorIterator that represents the concatenation of two other iterators.Classedu.stanford.nlp.utilJavaNlp
ConcurrentHashIndexA fast threadsafe index that supports constant-time lookup in both directions.Classedu.stanford.nlp.util.concurrentJavaNlp
ConfigDefines configuration settings for training and testing the neural-network dependency parser.Classedu.stanford.nlp.parser.nndepJavaNlp
ConfigurationDescribe the current configuration of a parser (i.Classedu.stanford.nlp.parser.nndepJavaNlp
ConfusionMatrixThis implements a confusion table over arbitrary types of class labels.Classedu.stanford.nlp.utilJavaNlp
CoNLL2011DocumentReaderRead _conll file format from CoNLL2011.Classedu.stanford.nlp.dcorefJavaNlp
CoNLLDocumentReaderRead _conll file format from CoNLL2011.Classedu.stanford.nlp.hcoref.docreaderJavaNlp
CoNLLDocumentReaderAndWriterDocumentReader for the original CoNLL 03 format.Classedu.stanford.nlp.sequencesJavaNlp
CoNLLOutputterWrite a subset of our CoreNLP output in CoNLL format.Classedu.stanford.nlp.pipelineJavaNlp
CoNLLUDocumentReaderReader for ConLL-U formatted dependency treebanks.Classedu.stanford.nlp.trees.udJavaNlp
CoNLLUOutputterWrite a subset of our CoreNLP output in CoNLL-U format.Classedu.stanford.nlp.pipelineJavaNlp
CoNLLUUtilsUtility functions for reading and writing CoNLL-U files.Classedu.stanford.nlp.trees.udJavaNlp
ConnectedComponentsFinds connected components in the graph, currently uses inefficient list for variable 'verticesLeft'.Classedu.stanford.nlp.graphJavaNlp
ConstituentA Constituent object defines a generic edge in a graph.Classedu.stanford.nlp.treesJavaNlp
ConstituentFactoryA ConstituentFactory is a factory for creating objects of class Constituent, or some descendent class.Interfaceedu.stanford.nlp.treesJavaNlp
ConvertByteArrayThis is used to convert an array of double into byte array which makes it possible to keep it more efficiently.Classedu.stanford.nlp.utilJavaNlp
CoordinationTransformerCoordination transformer transforms a PennTreebank tree containing a coordination in a flat structure in order to get the dependenciesClassedu.stanford.nlp.treesJavaNlp
CopulaHeadFinderA mix-in interface for HeadFinders which support the makesCopulaHead method, which says how the HeadFinder in questionInterfaceedu.stanford.nlp.treesJavaNlp
CoreAnnotationThe base class for any annotation that can be marked on a CoreMap, parameterized by the type of the value associated with the annotation.Interfaceedu.stanford.nlp.lingJavaNlp
CoreAnnotations Set of common annotations for CoreMaps.Classedu.stanford.nlp.lingJavaNlp
CorefAnnotatorThis class adds coref information to an Annotation.Classedu.stanford.nlp.pipelineJavaNlp
CorefChainOutput of (deterministic) coref system.Classedu.stanford.nlp.dcorefJavaNlp
CorefChainOutput of (deterministic) coref system.Classedu.stanford.nlp.hcoref.dataJavaNlp
CorefClusterOne cluster for the SieveCoreferenceSystem.Classedu.stanford.nlp.dcorefJavaNlp
CorefClusterOne cluster for the SieveCoreferenceSystem.Classedu.stanford.nlp.hcoref.dataJavaNlp
CorefCoreAnnotationsSimilar to CoreAnnotations, but this class containsClassedu.stanford.nlp.dcorefJavaNlp
CorefCoreAnnotationsSimilar to CoreAnnotations, but this class containsClassedu.stanford.nlp.hcorefJavaNlp
CorefDictionaryMatchSieve that uses the coreference dictionary for the technical domain developed by Recasens, Can and Jurafsky (NAACL 2013).Classedu.stanford.nlp.dcoref.sievepassesJavaNlp
CorefDictionaryMatchSieve that uses the coreference dictionary for the technical domain developed by Recasens, Can and Jurafsky (NAACL 2013).Classedu.stanford.nlp.hcoref.sieveJavaNlp
CorefDocMakermake Document for coref input from Annotation and optional info read input (raw, conll etc) with DocReader, mention detection, and document preprocessing will be done hereClassedu.stanford.nlp.hcorefJavaNlp
CorefMentionFinderInterface for finding coref mentions in a document.Interfaceedu.stanford.nlp.dcorefJavaNlp
CorefMentionFinderInterface for finding coref mentions in a document.Classedu.stanford.nlp.hcoref.mdJavaNlp
CorefScorerWrapper for a coreference resolution score: MUC, B cubed, Pairwise.Classedu.stanford.nlp.dcorefJavaNlp
CoreLabelA CoreLabel represents a single word with ancillary information attached using CoreAnnotations.Classedu.stanford.nlp.lingJavaNlp
CoreLabelTokenFactoryConstructs CoreLabels from Strings optionally with beginning and ending (character after the end) offset positions inClassedu.stanford.nlp.processJavaNlp
CoreMap Base type for all annotatable core objects.Interfaceedu.stanford.nlp.utilJavaNlp
CoreMapAttributeAggregatorFunctions for aggregating token attributes.Classedu.stanford.nlp.pipelineJavaNlp
CoreMapExpressionExtractorRepresents a list of assignment and extraction rules over sequence patterns.Classedu.stanford.nlp.ling.tokensregexJavaNlp
CoreMapExpressionNodePatternPattern for matching a CoreMap using a generic expressionAuthor:Angel ChangSee Also:Serialized FormClassedu.stanford.nlp.ling.tokensregexJavaNlp
CoreMapNodePatternPattern for matching a CoreMapAuthor:Angel ChangSee Also:Serialized FormClassedu.stanford.nlp.ling.tokensregexJavaNlp
CoreMapNodePatternTriggerTrigger for CoreMap Node Patterns.Classedu.stanford.nlp.ling.tokensregexJavaNlp
CoreTokenFactoryTo make tokens like CoreMap or CoreLabel.Interfaceedu.stanford.nlp.processJavaNlp
CorpusCharCheck tag of each character from 5 different corpora.Classedu.stanford.nlp.wordsegJavaNlp
CorpusDictionaryCheck if a bigram exists in bakeoff corpora.Classedu.stanford.nlp.wordsegJavaNlp
CounterAn Object to double map used for keeping weights or counts for objects.Interfaceedu.stanford.nlp.statsJavaNlp
CountersStatic methods for operating on a Counter.Classedu.stanford.nlp.statsJavaNlp
CountWrapperA simple data structure for some tag counts.Classedu.stanford.nlp.tagger.maxentJavaNlp
CreateSubtreeNodeGiven the start and end children of a particular node, takes all children between start and end (including the endpoints) andClassedu.stanford.nlp.trees.tregex.tsurgeonJavaNlp
CRFBiasedClassifierCRFBiasedClassifier is used to adjust the precision-recall tradeoff of any CRF model implemented using
CRFClassifierClass for sequence classification using a Conditional Random Field
CRFClassifierEvaluatorEvaluates CRFClassifier on a set of data - called by QNMinimizer
CRFClassifierNonlinearSubclass of CRFClassifier for implementing the nonlinear architecture in [Wang and Manning IJCNLP-2013 Effect of Nonlinear
CRFClassifierWithDropoutSubclass of CRFClassifier that performs dropout feature-noising
CRFClassifierWithLOPSubclass of CRFClassifier for learning Logarithmic Opinion
CRFCliqueTreeBuilds a CliqueTree (an array of FactorTable) and does message passing inference along
CRFDatumThe representation of Datums used internally in
CRFFeatureExporterExports CRF features for use with other
CRFLogConditionalObjectiveFunctionForLOP TODO(mengqiu) currently only works with disjoint feature sets for non-disjoint feature sets, need to recompute EHat each iteration, and multiply in the
CrossValidatorThis class is meant to simplify performing cross validation of classifiers for hyper-parameters.Classedu.stanford.nlp.classifyJavaNlp
CTBErrorCorrectingTreeNormalizerThis was originally written to correct a few errors Galen found in
CTBTreeReaderFactoryThe CTBTreeReaderFactory is a factory for creating a TreeReader suitable for the Penn Chinese Treebank (CTB)
CTBunkDictReturns "1" as true if the dictionary listed this word with this tag, and "0" otherwise.Classedu.stanford.nlp.tagger.maxentJavaNlp
CustomAnnotationSerializerSerializes Annotation objects using our own format.Classedu.stanford.nlp.pipelineJavaNlp
DataFilePathsSimple utility class: reads the environment variable in ENV_VARIABLE and provides a method that converts strings whichClassedu.stanford.nlp.utilJavaNlp
DataGenericA class representing a data item with an array of inputs X and a String classification Y.Classedu.stanford.nlp.maxentJavaNlp
DataInstanceIt's a list of Corelabels for SurfacePattern, Dependency parse for DepPattern etc Created by sonalg on 11/1/14.Classedu.stanford.nlp.patternsJavaNlp
DataInstanceDepCreated by sonalg on 11/1/14.Classedu.stanford.nlp.patterns.depJavaNlp
DataInstanceSurfaceCreated by sonalg on 11/1/14.Classedu.stanford.nlp.patterns.surfaceJavaNlp
DatasetAn interfacing class for ClassifierFactory that incrementally builds a more memory-efficient representation of a List ofClassedu.stanford.nlp.classifyJavaNlp
DatasetDefines a list of training / testing examples in multi-class classification setting.Classedu.stanford.nlp.parser.nndepJavaNlp
DatasetA generic interface loading, processing, and writing a data set.Interfaceedu.stanford.nlp.trees.treebankJavaNlp
DateTreeTransformerFlattens the following two structures: (NP (NP (NNP Month) (CD Day) )Classedu.stanford.nlp.treesJavaNlp
DatumInterface for Objects which can be described by their features.Interfaceedu.stanford.nlp.lingJavaNlp
DebinarizerDebinarizes a binary tree from the parser.Classedu.stanford.nlp.parser.lexparserJavaNlp
DeepTreeA tree combined with a map from subtree to SimpleMatrix vectors.Classedu.stanford.nlp.treesJavaNlp
DefaultLexicalMapperApplies a default set of lexical transformations that have been empirically validated in various Arabic
DefaultPathsDefault model paths for StanfordCoreNLP All these paths point to files distributed with the model jar file (stanford-corenlp-models-*.Classedu.stanford.nlp.pipelineJavaNlp
DefaultTeXHyphenDataDefault TeX hyphenation data, as borrowed from the TeX
DelimitRegExIteratorAn Iterator that reads the contents of a Reader, delimited by the specified delimiter, and then be subsequently processed by an Function to produceClassedu.stanford.nlp.objectbankJavaNlp
DeltaCollectionValuedMap map and changes to that map.Classedu.stanford.nlp.utilJavaNlp
DeltaIndexA class that has a backing index, such as a hash index you don't want changed, and another index which will hold extra entries thatClassedu.stanford.nlp.utilJavaNlp
DeltaMapA Map which wraps an original Map, and only stores the changes (deltas) from the original Map.Classedu.stanford.nlp.utilJavaNlp
DependenciesUtilities for Dependency objects.Classedu.stanford.nlp.treesJavaNlp
DependencyAn individual dependency between a governor and a dependent.Interfaceedu.stanford.nlp.treesJavaNlp
DependencyFactoryA factory for dependencies of a certain type.Interfaceedu.stanford.nlp.treesJavaNlp
DependencyGrammarAn interface for DependencyGrammars.Interfaceedu.stanford.nlp.parser.lexparserJavaNlp
DependencyParseAnnotatorThis class adds dependency parse information to an Annotation.Classedu.stanford.nlp.pipelineJavaNlp
DependencyParserThis class defines a transition-based dependency parser which makes use of a classifier powered by a neural network.Classedu.stanford.nlp.parser.nndepJavaNlp
DependencyParserDemoDemonstrates how to first use the tagger, then use the NN dependency parser.Classedu.stanford.nlp.parser.nndep.demoJavaNlp
DependencyTreeTransformerTransforms an English structure parse tree in order to get the dependencies right: -- put a ROOT node Classedu.stanford.nlp.treesJavaNlp
DependencyTyperA generified interface for making some kind of dependency object between a head and dependent.Interfaceedu.stanford.nlp.treesJavaNlp
DepPatternCreated by sonalg on 10/31/14.Classedu.stanford.nlp.patterns.depJavaNlp
DepPatternFactoryCreated by Sonal Gupta on 10/31/14.Classedu.stanford.nlp.patterns.depJavaNlp
DeterministicCorefAnnotator In other words, this depends on: POSTaggerAnnotator, NERCombinerAnnotator (or equivalent), and ParserAnnotator.Classedu.stanford.nlp.pipelineJavaNlp
DeterministicCorefSieveBase class for a Coref Sieve.Classedu.stanford.nlp.dcoref.sievepassesJavaNlp
DeterministicCorefSieveBase class for a Coref Sieve.Classedu.stanford.nlp.hcoref.sieveJavaNlp
DFSADFSA: A class for representing a deterministic finite state automaton without epsilon transitions.Classedu.stanford.nlp.fsmJavaNlp
DFSAStateDFSAState represents the state of a deterministic finite state automaton without epsilon transitions.Classedu.stanford.nlp.fsmJavaNlp
DFSATransitionDFSATransition represents a transition in a weighted finite state transducer.Classedu.stanford.nlp.fsmJavaNlp
DictionariesProvides accessors for various grammatical, semantic, and world knowledge lexicons and word lists primarily used by the Sieve coreference system,Classedu.stanford.nlp.dcorefJavaNlp
DictionaryMaintains a map from words to tags and their counts.Classedu.stanford.nlp.tagger.maxentJavaNlp
DictionaryExtractorThis class is the same as a regular Extractor, but keeps a pointer to the tagger's dictionary as well.Classedu.stanford.nlp.tagger.maxentJavaNlp
DiffFloatFunctionAn interface for once-differentiable double-valued functions over double arrays.Interfaceedu.stanford.nlp.optimizationJavaNlp
DiffFunctionAn interface for once-differentiable double-valued functions over double arrays.Interfaceedu.stanford.nlp.optimizationJavaNlp
DirectedMultiGraphSimple graph library; this is directed for now.Classedu.stanford.nlp.graphJavaNlp
DisabledPreferencesA do-nothing Preferences implementation so that we can avoid the hassles of the JVM Preference implementations.Classedu.stanford.nlp.utilJavaNlp
DisabledPreferencesFactoryReturns do-nothing Preferences implementation.Classedu.stanford.nlp.utilJavaNlp
DiskTreebankA DiskTreebank is a Collection of A DiskTreebank object stores merely the information toClassedu.stanford.nlp.treesJavaNlp
DisplayMatchesPanelClass for creating the panel which shows a graphical version of the tree (as in TreeJPanel) as well as the file name of the file from which the tree is from.Classedu.stanford.nlp.trees.tregex.guiJavaNlp
DistributionImmutable class for representing normalized, smoothed discrete distributions from Counters.Classedu.stanford.nlp.statsJavaNlp
DistributionPackageAdds data files to a tar'd / gzip'd distribution package.Classedu.stanford.nlp.trees.treebankJavaNlp
DistsimKeeps track of a distributional similarity mapping, eg a map from word to class.Classedu.stanford.nlp.tagger.maxentJavaNlp
DistSimClassifierMaps a String to its distributional similarity class.Classedu.stanford.nlp.processJavaNlp
DistsimFeatureFactoryFeaturizes words based only on their distributional similarity classes.Classedu.stanford.nlp.parser.shiftreduceJavaNlp
DocReaderRead raw, CoNLL, ACE, or MUC document and return InputDocRead raw, CoNLL, ACE, or MUC document and return InputDocInterfaceedu.stanford.nlp.hcoref.docreaderJavaNlp
DocumentRepresents a text document as a list of Words with a String title.Interfaceedu.stanford.nlp.lingJavaNlp
DocumentA representation of a Document.Classedu.stanford.nlp.simpleJavaNlp
DocumentPreprocessorProduces a list of sentences from either a plain text or XML document.Classedu.stanford.nlp.processJavaNlp
DocumentProcessorTop-level interface for transforming Documents.Interfaceedu.stanford.nlp.processJavaNlp
DocumentReaderBasic mechanism for reading in Documents from various input sources.Classedu.stanford.nlp.lingJavaNlp
DocumentReaderAndWriterThis interface is used for reading data and writing output into and out of sequence classifiers.Interfaceedu.stanford.nlp.sequencesJavaNlp
DoubleADThe class DoubleAD was created to extend the current calculations of gradient to automatically include a calculation of theClassedu.stanford.nlp.mathJavaNlp
EdgeClass for parse edges.Classedu.stanford.nlp.parser.lexparserJavaNlp
EditDistanceFind the (Levenshtein) edit distance between two Strings or Character By default it allows transposition.Classedu.stanford.nlp.utilJavaNlp
EditDistanceDamerauLevenshteinLikeCOPIED FROM https://gist.Classedu.stanford.nlp.patternsJavaNlp
EncodingFileReaderThis is a convenience class which works almost exactly like but allows for the specification of input encoding.Classedu.stanford.nlp.ioJavaNlp
EncodingPrintWriterA convenience IO class with print and println statements to standard output and standard error allowing encoding in anClassedu.stanford.nlp.ioJavaNlp
EnglishGrammaticalRelationsEnglishGrammaticalRelations is a set of GrammaticalRelation objects for the English language.Classedu.stanford.nlp.treesJavaNlp
EnglishGrammaticalStructureA GrammaticalStructure for English.Classedu.stanford.nlp.treesJavaNlp
EnglishPatternsThis class contains some English String or Tregex regular expression patterns.Classedu.stanford.nlp.treesJavaNlp
EnglishTreebankParserParamsParser parameters for the Penn English Treebank (WSJ, Brown, Switchboard).Classedu.stanford.nlp.parser.lexparserJavaNlp
EnglishUnknownWordModelThis is a basic unknown word model for English.Classedu.stanford.nlp.parser.lexparserJavaNlp
EntityCachingAbstractSequencePriorBIOThis class keeps track of all labeled entities and updates the its list whenever the label at a point gets changed.Classedu.stanford.nlp.ieJavaNlp
EntityMentionEach entity mention is described by a type (possibly subtype) and a span of textAuthor:Andrey Gusev, MihaiSee Also:Serialized
EntityMentionsAnnotatorAnnotator that marks entity mentions in a document.Classedu.stanford.nlp.pipelineJavaNlp
EnvHolds environment variables to be used for compiling string into a pattern.Classedu.stanford.nlp.ling.tokensregexJavaNlp
EnvCreated by sonalg on 11/3/14.Classedu.stanford.nlp.semgraph.semgrexJavaNlp
EnvLookupProvides lookup functions using an EnvClassedu.stanford.nlp.ling.tokensregexJavaNlp
EquivalenceClasserA strategy-type interface for specifying a function from Objects to their equivalence classes.Interfaceedu.stanford.nlp.statsJavaNlp
ErasureUtilsClass to gather unsafe operations into one place.Classedu.stanford.nlp.utilJavaNlp
EvalAn interface which can be implemented by anything that evaluates one tree at a time and then prints out a summary when done.Interfaceedu.stanford.nlp.parser.metricsJavaNlp
EvalbA Java re-implementation of the evalb bracket scoring metric (Collins, 1997) that accepts Unicode input.Classedu.stanford.nlp.parser.metricsJavaNlp
EvalbByCatComputes labeled precision and recall (evalb) at the constituent category level.Classedu.stanford.nlp.parser.metricsJavaNlp
ExactBestSequenceFinderA class capable of computing the best sequence given a SequenceModel.Classedu.stanford.nlp.sequencesJavaNlp
ExecutionA class to set command line options.Classedu.stanford.nlp.utilJavaNlp
ExhaustiveDependencyParserAn exhaustive O(n4t2) time and O(n2t) space dependency parser.Classedu.stanford.nlp.parser.lexparserJavaNlp
ExhaustivePCFGParserAn exhaustive generalized CKY PCFG parser.Classedu.stanford.nlp.parser.lexparserJavaNlp
ExperimentsThis class represents the training samples.Classedu.stanford.nlp.maxentJavaNlp
ExpressionThis interface represents an expression that can be evaluated to obtain a value.Interfaceedu.stanford.nlp.ling.tokensregex.typesJavaNlp
ExpressionsVarious implementations of the Expression interface, which is used for specifying an "action" or "result" in TokensRegex extraction rules.Classedu.stanford.nlp.ling.tokensregex.typesJavaNlp
ExtractionObjectRepresents any object that can be extracted - entity, relation, eventAuthor:Andrey Gusev, MihaiSee Also:Serialized
ExtractorAnnotates the given dataset with the current model This works in place,
ExtractorThis class serves as the base class for classes which extract relevant information from a history to give it to the features.Classedu.stanford.nlp.tagger.maxentJavaNlp
ExtractorDistsimExtractor for adding distsim information.Classedu.stanford.nlp.tagger.maxentJavaNlp
ExtractorDistsimConjunctionExtractor for adding a conjunction of distsim information.Classedu.stanford.nlp.tagger.maxentJavaNlp
ExtractorFramesThis class contains the basic feature extractors used for all words and tag sequences (and interaction terms) for the MaxentTagger, but not theClassedu.stanford.nlp.tagger.maxentJavaNlp
ExtractorFramesRareThis class contains feature extractors for the MaxentTagger that are only applied to rare (low frequency/unknown) words.Classedu.stanford.nlp.tagger.maxentJavaNlp
ExtractorMergerSimple extractor which combines several other
ExtractorsMaintains a set of feature extractors and applies them.Classedu.stanford.nlp.tagger.maxentJavaNlp
ExtractorVerbalVBNZeroLook for verbs selecting a VBN verb.Classedu.stanford.nlp.tagger.maxentJavaNlp
FactoredSequenceModel Date: Dec 14, 2004, nmramesh Date: May 12, 2010Classedu.stanford.nlp.sequencesJavaNlp
FactorTableStores a factor table as a one dimensional array of
FactoryA generified factory class which creates instances of a particular type.Interfaceedu.stanford.nlp.utilJavaNlp
FastExactAutomatonMinimizerMinimization in n log n a la Hopcroft.Classedu.stanford.nlp.fsmJavaNlp
FastFactoredParserProvides a much faster way to realize the factored parsing idea, including easily returning "k good" resultsClassedu.stanford.nlp.parser.lexparserJavaNlp
FeatureThis class is used as a base class for TaggerFeature for the tagging problem and for BinaryFeature for the general problem with binaryClassedu.stanford.nlp.maxentJavaNlp
FeatureFactoryThis is the abstract class that all feature factories must subclass.Classedu.stanford.nlp.sequencesJavaNlp
FeatureKeyStores a triple of an extractor ID, a feature value (derived from history) and a y (tag) value.Classedu.stanford.nlp.tagger.maxentJavaNlp
FeaturizableInterface for Objects that can be described by their features.Interfaceedu.stanford.nlp.lingJavaNlp
FilePanelClass representing the hierarchy of files in which trees may be searched and allowing users to select whether to search a particular file or notClassedu.stanford.nlp.trees.tregex.guiJavaNlp
FilePathProcessorThe FilePathProcessor traverses a directory structure and applies the processFile method to files meeting someClassedu.stanford.nlp.utilJavaNlp
FileProcessorInterface for a Visitor pattern for Files.Interfaceedu.stanford.nlp.utilJavaNlp
FileSequentialCollectionA FileSequentialCollection maintains a read-only collection of Files.Classedu.stanford.nlp.ioJavaNlp
FileSystemProvides various filesystem operations common to scripting languages such as Perl and Python but not present (currently) in the Java standard libraries.Classedu.stanford.nlp.ioJavaNlp
FileTreeModelComponent for managing the data for files containing trees.Classedu.stanford.nlp.trees.tregex.guiJavaNlp
FileTreeNodeRepresents a node in a JTree that holds a file and displays the short name of the file in the JTree.Classedu.stanford.nlp.trees.tregex.guiJavaNlp
FilterConfusingRulesThis filter rejects Trees which have unary or binary productions which the given parser does not contain.Classedu.stanford.nlp.parser.dvparserJavaNlp
FilteredEvalAn AbstractEval which doesn't just evaluate all constituents, but lets you provide a filter to only pay attention to constituentsClassedu.stanford.nlp.parser.metricsJavaNlp
FilteredIteratorIterator that suppresses items in another iterator based on a filter function.Classedu.stanford.nlp.utilJavaNlp
FilteringTreeReaderA FilteringTreeReader filters the output of another TreeReader.Classedu.stanford.nlp.treesJavaNlp
FiltersStatic class with some useful Predicate implementations and utility methods for working Contains filters that always accept or reject, filters that accept or reject an Object if it's in a givenClassedu.stanford.nlp.utilJavaNlp
FinalizeTransitionTransition that finishes the processing of a stateSee Also:Serialized FormClassedu.stanford.nlp.parser.shiftreduceJavaNlp
FixedPrioritiesPriorityQueueA priority queue based on a binary heap.Classedu.stanford.nlp.utilJavaNlp
FloatFactorTableStores a factor table as a one dimensional array of
FloatFunctionAn interface for double-valued functions over double arrays.Interfaceedu.stanford.nlp.optimizationJavaNlp
FontDetectorDetects which Fonts can be used to display unicode characters in a given language.Classedu.stanford.nlp.swingJavaNlp
ForwardEntailerA class to find the forward entailments warranted by a particular sentence or clause.Classedu.stanford.nlp.naturalliJavaNlp
ForwardEntailerSearchProblemA particular instance of a search problem for finding entailed sentences.Classedu.stanford.nlp.naturalliJavaNlp
FrenchHeadFinderTODO wsg2010: Compare these head finding rules to those found in Arun Abishek's Author:mcdmSee Also:Serialized
FrenchTokenizerTokenizer for raw French
FrenchTreebankLanguagePackLanguage pack for the French
FrenchTreebankParserParamsTreebankLangParserParams for the French Treebank corpus.Classedu.stanford.nlp.parser.lexparserJavaNlp
FrenchTreeNormalizerPrepares French Treebank trees for
FrenchTreeReaderFactoryA class for reading French Treebank trees that have been converted from XML to PTB
FrenchUnknownWordSignaturesContains patterns for matching certain word types in French, such as common suffices for nouns, verbs, adjectives and
FrenchXMLTreeReaderA reader for XML format French Treebank
FrenchXMLTreeReaderFactoryA class for reading French Treebank trees that have been converted from XML to PTB
FTBCorrectorMakes FTB trees consistent with
FTBCorrectorVisitorWrapper class for using the ATBCorrector class with TreebankPipeline's TVISITOR
FTBDatasetProduces the pre-processed version of the FTB used in the experiments of Green et
FunctionAn interface for double-valued functions over double arrays.Interfaceedu.stanford.nlp.optimizationJavaNlp
FuzzyIntervalA FuzzyInterval is an extension of Interval where not all endpoints are always specified or comparable.Classedu.stanford.nlp.utilJavaNlp
Gale2007ChineseSegmenterFeatureFactoryA Chinese segmenter Feature Factory for the GALE project.Classedu.stanford.nlp.wordsegJavaNlp
GenderAnnotatorThis class adds gender information (MALE / FEMALE) to tokens as GenderAnnotations.Classedu.stanford.nlp.pipelineJavaNlp
GeneralDatasetThe purpose of this interface is to unify Dataset and RVFDataset.Classedu.stanford.nlp.classifyJavaNlp
GeneralizedCounterA class for keeping double counts of Lists of a prespecified length.Classedu.stanford.nlp.statsJavaNlp
GeneralizedExpectationObjectiveFunction an I.Classedu.stanford.nlp.classifyJavaNlp
GenericsA collection of utilities to make dealing with Java generics less painful and verbose.Classedu.stanford.nlp.utilJavaNlp
GenericTimeExpressionPatternsProvides generic mechanism to convert natural language into temporal representation by reading patterns/rules specifying mapping between text and temporal objectsClassedu.stanford.nlp.timeJavaNlp
GermanUnknownWordModelAn unknown word model for German; relies on BaseUnknownWordModel plus number matching.Classedu.stanford.nlp.parser.lexparserJavaNlp
GetPatternsFromDataMultiClassGiven text and a seed list, this class gives more words like the seed words by learning surface word or dependency patterns.Classedu.stanford.nlp.patternsJavaNlp
GoldenSectionLineSearchA class to do golden section line search.Classedu.stanford.nlp.optimizationJavaNlp
GoogleNGramsSQLBackedTo query Google Ngrams counts from SQL in a memory efficient manner.Classedu.stanford.nlp.utilJavaNlp
GrammarProjectionMaps between the states of a more split and less split grammar.Interfaceedu.stanford.nlp.parser.lexparserJavaNlp
GrammaticalFunctionTreeNormalizerTree normalizer for cleaning up labels and preserving the whole node label, the grammatical function and category information from the label, or onlyClassedu.stanford.nlp.treesJavaNlp
GrammaticalRelationGrammaticalRelation is used to define a standardized, hierarchical set of grammatical relations,Classedu.stanford.nlp.treesJavaNlp
GrammaticalStructureA GrammaticalStructure stores dependency relations between nodes in a tree.Classedu.stanford.nlp.treesJavaNlp
GrammaticalStructureFactoryA general factory for GrammaticalStructure objects.Interfaceedu.stanford.nlp.treesJavaNlp
GrammaticalStructureFromDependenciesFactoryAn interface for a factory that builds a GrammaticalStructure from a list of TypedDependencies and a TreeGraphNode.Interfaceedu.stanford.nlp.treesJavaNlp
GraphAdds vertices (if not already in the graph) and the edge between them.Interfaceedu.stanford.nlp.graphJavaNlp
GUTimeAnnotatorAnnotates text using GUTime perl script.Classedu.stanford.nlp.timeJavaNlp
HasCategorySomething that implements the HasCategory interface knows about categories.Interfaceedu.stanford.nlp.lingJavaNlp
HasCliquePotentialFunctionIndicates that this function can build a clique potential function for external
HasContextReturn the whitespace String after the word.Interfaceedu.stanford.nlp.lingJavaNlp
HasFloatInitialIndicates that a function has a method for supplying an intitial value.Interfaceedu.stanford.nlp.optimizationJavaNlp
HashableCoreMapAn extension of ArrayCoreMap with an immutable set of key,value pairs that is used for equality and hashcode comparisons.Classedu.stanford.nlp.utilJavaNlp
HashIndex both directions (via get(int) and indexOf(E).Classedu.stanford.nlp.utilJavaNlp
HasInitialIndicates that a function has a method for supplying an intitial value.Interfaceedu.stanford.nlp.optimizationJavaNlp
HasLemmaSomething that implements the HasLemma interface knows about lemmas.Interfaceedu.stanford.nlp.lingJavaNlp
HasOffsetSomething that implements the HasOffset interface bears a offset reference to the original textInterfaceedu.stanford.nlp.lingJavaNlp
HasParentOnly to be implemented by Tree subclasses that actualy keep their parent pointers.Interfaceedu.stanford.nlp.treesJavaNlp
HasRegularizerParamRangeIndicates that a Function should only be regularized on a subsetgetRegularizerParamRangeInterfaceedu.stanford.nlp.optimizationJavaNlp
HasTagSomething that implements the HasTag interface knows about part-of-speech tags.Interfaceedu.stanford.nlp.lingJavaNlp
HasWordSomething that implements the HasWord interfaceAuthor:Christopher ManningInterfaceedu.stanford.nlp.lingJavaNlp
HeadFinderAn interface for finding the "head" daughter of a phrase structure tree.Interfaceedu.stanford.nlp.treesJavaNlp
Heap These heaps implement a decreaseKey operation, which requires a separate Object to Index map, and for objects to be unique in the Heap.Interfaceedu.stanford.nlp.utilJavaNlp
HebrewTreebankParserParamsInitial version of a parser pack for the HTB.Classedu.stanford.nlp.parser.lexparserJavaNlp
HeidelTimeAnnotatorAnnotates text using HeidelTime.Classedu.stanford.nlp.timeJavaNlp
HistoryTableNotes: This maintains a two way lookup between a History andVersion:1.Classedu.stanford.nlp.tagger.maxentJavaNlp
HookClass for parse table hooks.Classedu.stanford.nlp.parser.lexparserJavaNlp
HybridMinimizerHybrid Minimizer is set up as a combination of two minimizers.Classedu.stanford.nlp.optimizationJavaNlp
IBMArabicEscaperThis escaper is intended for use on flat input to be parsed by
IdentityFunctionAn Identity function that returns its argument.Classedu.stanford.nlp.objectbankJavaNlp
IdentityHashSetThis class provides a IdentityHashMap-backed implementation of the Set interface.Classedu.stanford.nlp.utilJavaNlp
IdleTransitionTransition that literally does nothingSee Also:Serialized FormClassedu.stanford.nlp.parser.shiftreduceJavaNlp
IndexA collection that maps between a vocabulary of type E and a continuous non-negative integer index series beginning (inclusively) at 0.Classedu.stanford.nlp.utilJavaNlp
IndexedWordThis class provides a CoreLabel that uses its DocIDAnnotation, SentenceIndexAnnotation, and IndexAnnotation to implementClassedu.stanford.nlp.lingJavaNlp
InefficientSGDMinimizerStochastic Gradient Descent Minimizer.Classedu.stanford.nlp.optimizationJavaNlp
InputDocInput document read from input source (CoNLL, ACE, MUC, or raw text) Stores Annotation, gold info (optional) and additional document information (optional)Classedu.stanford.nlp.hcoref.dataJavaNlp
InputPanelClass representing the panel that gets input from the user and does (in a thread-safe manner) the computation for finding tree matches and performing tsurgeon operations.Classedu.stanford.nlp.trees.tregex.guiJavaNlp
IntCounterA specialized kind of hash table (or map) for storing numeric counts for objects.Classedu.stanford.nlp.statsJavaNlp
IntDependencyMaintains a dependency between head and dependent where they are each an IntTaggedWord.Classedu.stanford.nlp.parser.lexparserJavaNlp
InternerFor interning (canonicalizing) things.Classedu.stanford.nlp.utilJavaNlp
IntervalRepresents a interval of a generic type E that is comparable.Classedu.stanford.nlp.utilJavaNlp
IntervalTreeAn interval tree maintains a tree so that all intervals to the left start before current interval and all intervals to the right start after.Classedu.stanford.nlp.utilJavaNlp
IntTaggedWordRepresents a WordTag (in the sense that equality is defined on both components), where each half is represented by anClassedu.stanford.nlp.parser.lexparserJavaNlp
IntTupleA tuple of int.Classedu.stanford.nlp.utilJavaNlp
IntUniJust a single integerAuthor:Kristina Toutanova (kristina@cs.Classedu.stanford.nlp.utilJavaNlp
InvertedIndexByTokensCreates an inverted index of (classkey:value) => {sentid1,sentid2,.Classedu.stanford.nlp.patternsJavaNlp
IOBUtilsA class for converting strings to input suitable for processing by an IOB sequence
IOBUtilsA static class with functions to convert lists of tokens between different IOB-style representations.Classedu.stanford.nlp.sequencesJavaNlp
IOUtilsHelper Class for various I/O related things.Classedu.stanford.nlp.ioJavaNlp
ISODateInstanceRepresents dates and times according to ISO8601 standard while also allowing for wild cards -
ItemAbstract class for parse items.Classedu.stanford.nlp.parser.lexparserJavaNlp
IterableIteratorThis cures a pet peeve of mine: that you can't use an Iterator directly in Java 5's foreach construct.Classedu.stanford.nlp.utilJavaNlp
IterablesUtilities for helping out with Iterables as Collections is to Collection.Classedu.stanford.nlp.utilJavaNlp
IterativeCKYPCFGParserDoes iterative deepening search inside the CKY algorithm for faster parsing.Classedu.stanford.nlp.parser.lexparserJavaNlp
IteratorFromReaderFactoryAn IteratorFromReaderFactory is used to convert a java.Interfaceedu.stanford.nlp.objectbankJavaNlp
JarFileChooserThis class shows a dialog which lets the user select a file from among a list of files contained in a given jar file.Classedu.stanford.nlp.uiJavaNlp
JavaUtilLoggingAdaptorReroutes java.Classedu.stanford.nlp.util.loggingJavaNlp
JavaUtilLoggingHandlerAn outputter that writes to Java Util Logging logs.Classedu.stanford.nlp.util.loggingJavaNlp
JodaTimeUtilsExtensions to Joda time.Classedu.stanford.nlp.timeJavaNlp
JollyDayHolidaysWrapper around jollyday library so we can hook in holiday configurations from jollyday with SUTime.Classedu.stanford.nlp.timeJavaNlp
JSONOutputterOutput an Annotation to human readable JSON.Classedu.stanford.nlp.pipelineJavaNlp
KBestSequenceFinderA SequenceFinder which can efficiently return a k-best list of sequence labellings.Classedu.stanford.nlp.sequencesJavaNlp
KBestViterbiParserAn interface that supports finding k best and/or k good parses and parse sampling.Interfaceedu.stanford.nlp.parserJavaNlp
LabelSomething that implements the Label interface can act as a constituent, node, or word label with linguistic attributes.Interfaceedu.stanford.nlp.lingJavaNlp
LabelDictionaryConstrains test-time inference to labels observed in
LabeledInterface for Objects that have a label, whose label is an Object.Interfaceedu.stanford.nlp.lingJavaNlp
LabeledInterface for Objects which have a Label.Interfaceedu.stanford.nlp.treesJavaNlp
LabeledChunkIdentifierIdentifies chunks based on labels that uses IOB like encoding Assumes labels have the form -Classedu.stanford.nlp.pipelineJavaNlp
LabeledConstituentA LabeledConstituent object represents a single bracketing in a derivation, including start and end points and LabelClassedu.stanford.nlp.treesJavaNlp
LabeledScoredConstituentA LabeledScoredConstituent object defines an edge in a graph with a label and a score.Classedu.stanford.nlp.treesJavaNlp
LabeledScoredConstituentFactoryA LabeledScoredConstituentFactory acts as a factory for creating objects of class LabeledScoredConstituent.Classedu.stanford.nlp.treesJavaNlp
LabeledScoredTreeFactoryA LabeledScoredTreeFactory acts as a factory for creating trees with labels and scores.Classedu.stanford.nlp.treesJavaNlp
LabeledScoredTreeNodeA LabeledScoredTreeNode represents a tree composed of a root and an array of daughter parse trees.Classedu.stanford.nlp.treesJavaNlp
LabeledScoredTreeReaderFactoryThis class implements a TreeReaderFactory that produces labeled, scored array-based Trees, which have been cleaned up toClassedu.stanford.nlp.treesJavaNlp
LabeledWordA LabeledWord object contains a word and its tag.Classedu.stanford.nlp.lingJavaNlp
LabelFactoryA LabelFactory object acts as a factory for creating objects of class Label, or some descendant class.Interfaceedu.stanford.nlp.lingJavaNlp
LambdaSolveThis is the main class that does the core computation in IIS.Classedu.stanford.nlp.maxent.iisJavaNlp
LambdaSolveTaggerThis module does the working out of lambda parameters for binary tagger features.Classedu.stanford.nlp.tagger.maxentJavaNlp
LanguageConstants and parameters for multilingual NLP (primarily, parsing).Classedu.stanford.nlp.internationalJavaNlp
LatticeWriterThis interface is used for writing lattices out of SequenceClassifiers.Interfaceedu.stanford.nlp.sequencesJavaNlp
LazyAn instantiation of a lazy object.Classedu.stanford.nlp.utilJavaNlp
LDCPosMapperMaps pre-terminal ATB morphological analyses to the shortened Bies tag
LeafAncestorEval later analyzed more completely by Clegg and Shepherd (2005).Classedu.stanford.nlp.parser.metricsJavaNlp
LearnImportantFeaturesThe idea is that you can learn features that are important using ML algorithm and use those features in learning weights for patterns.Classedu.stanford.nlp.patterns.surfaceJavaNlp
LeftHeadFinderHeadFinder that always returns the leftmost daughter as head.Classedu.stanford.nlp.treesJavaNlp
LengthTreeFilterOnly accept trees that are short enough (less than or equal to length).Classedu.stanford.nlp.treesJavaNlp
LexedTokenFactoryConstructs a token (of arbitrary type) from a String and its position in the underlying text.Interfaceedu.stanford.nlp.processJavaNlp
LexerA Lexer interface to be used with LexerTokenizer.Interfaceedu.stanford.nlp.ioJavaNlp
LexerTokenizerAn implementation of Tokenizer designed to work with Lexer implementing classes.Classedu.stanford.nlp.processJavaNlp
LexicalizedParserThis class provides the top-level API and command-line interface to a set of reasonably good treebank-trained parsers.Classedu.stanford.nlp.parser.lexparserJavaNlp
LexicalizedParserClientThe sister class to LexicalizedParserServer.Classedu.stanford.nlp.parser.serverJavaNlp
LexicalizedParserQueryReturn the best parse of the sentence most recently parsed.Classedu.stanford.nlp.parser.lexparserJavaNlp
LexicalizedParserServerServes requests to the given parser model on the given port.Classedu.stanford.nlp.parser.serverJavaNlp
LexiconAn interface for lexicons interfacing to lexparser.Interfaceedu.stanford.nlp.parser.lexparserJavaNlp
LinearClassifier can be any generalized linear model classifier (such as a perceptron, a maxent classifier (softmax logistic regression), or an SVM).Classedu.stanford.nlp.classifyJavaNlp
LinearClassifierFactoryBuilds various types of linear classifiers, with functionality for setting objective function, optimization method, and other parameters.Classedu.stanford.nlp.classifyJavaNlp
LineIteratorAn Iterator that returns a line of a file at a time.Classedu.stanford.nlp.objectbankJavaNlp
LineSearcherThe interface for one variable function minimizers.Interfaceedu.stanford.nlp.optimizationJavaNlp
ListeningSequenceModelThis is simply a conjunctive interface for something that is a SequenceModel and a SequenceListener.Interfaceedu.stanford.nlp.sequencesJavaNlp
ListProcessorAn interface for things that operate on a List.Interfaceedu.stanford.nlp.processJavaNlp
LogConditionalEqConstraintFunctionMaximizes the conditional likelihood with a given prior.Classedu.stanford.nlp.classifyJavaNlp
LogConditionalObjectiveFunctionMaximizes the conditional likelihood with a given prior.Classedu.stanford.nlp.classifyJavaNlp
LogisticClassifierA classifier for binary logistic regression problems.Classedu.stanford.nlp.classifyJavaNlp
LogisticClassifierFactoryBuilds a classifier for binary logistic regression problems.Classedu.stanford.nlp.classifyJavaNlp
LogisticObjectiveFunctionMaximizes the conditional likelihood with a given prior.Classedu.stanford.nlp.classifyJavaNlp
LogPriorA Prior for functions.Classedu.stanford.nlp.classifyJavaNlp
LogRecordHandlerA log message handler.Classedu.stanford.nlp.util.loggingJavaNlp
MachineReadingMain driver for Machine Reading training, annotation, and
MacrosThis defines how to use macros from a file in Tregex.Classedu.stanford.nlp.trees.tregexJavaNlp
MapFactoryA factory class for vending different sorts of Maps.Classedu.stanford.nlp.utilJavaNlp
MapListThis implements a map to a set of lists.Classedu.stanford.nlp.utilJavaNlp
MapperGeneric interface for mapping one string to another given some contextual evidence.Interfaceedu.stanford.nlp.trees.treebankJavaNlp
MapsUtilities for Maps, including inverting, composing, and support for list/set values.Classedu.stanford.nlp.utilJavaNlp
MatchedExpressionMatched Expression represents a chunk of text that was matched from an original segment of text).Classedu.stanford.nlp.ling.tokensregexJavaNlp
MatchesPanelComponent for displaying the list of trees that matchAuthor:Anna RaffertySee Also:Serialized FormClassedu.stanford.nlp.trees.tregex.guiJavaNlp
MaxentTaggerThe main class for users to run, train, and test the part of speech tagger.Classedu.stanford.nlp.tagger.maxentJavaNlp
MaxentTaggerGUIA very simple GUI for illustrating the POS tagger tagging text.Classedu.stanford.nlp.tagger.maxentJavaNlp
MaxentTaggerServerA POS tagger server for the Stanford POS Tagger.Classedu.stanford.nlp.tagger.maxentJavaNlp
MaxSizeConcurrentHashSetA hash set supporting full concurrency of retrievals and high expected concurrency for updates but with an (adjustable) maximum size.Classedu.stanford.nlp.utilJavaNlp
MemoryMonitorUtilities for monitoring memory use, including peak memory use.Classedu.stanford.nlp.utilJavaNlp
MemoryTreebankA MemoryTreebank object stores a corpus of examples with given tree structures in memory (as a List).Classedu.stanford.nlp.treesJavaNlp
MentionOne mention for the SieveCoreferenceSystem.Classedu.stanford.nlp.dcorefJavaNlp
MentionOne mention for the SieveCoreferenceSystem.Classedu.stanford.nlp.hcoref.dataJavaNlp
MentionAnnotatorThis class adds mention information to an Annotation.Classedu.stanford.nlp.pipelineJavaNlp
MentionExtractorGeneric mention extractor from a corpus.Classedu.stanford.nlp.dcorefJavaNlp
MetaClassA meta class using Java's reflection library.Classedu.stanford.nlp.utilJavaNlp
MinimizerThe interface for unconstrained function minimizers.Interfaceedu.stanford.nlp.optimizationJavaNlp
MLEDependencyGrammarExtractorGathers statistics on tree dependencies and then passes them to an MLEDependencyGrammar for dependency grammar construction.Classedu.stanford.nlp.parser.lexparserJavaNlp
ModCollinsHeadFinder thesis.Classedu.stanford.nlp.treesJavaNlp
MonotonicityA monotonicity value.Classedu.stanford.nlp.naturalliJavaNlp
MonotonicityTypeenum MonotonicityTypeThe monotonicity type -- that is, additive, multiplicative, or both/neitherClassedu.stanford.nlp.naturalliJavaNlp
MorphaAnnotatorThis class will add the lemmas of all the words to the Annotation.Classedu.stanford.nlp.pipelineJavaNlp
MorphoFeaturesHolds a set of morphosyntactic features for a given surface
MorphoFeatureSpecificationMorphological feature specification for surface forms in a given
MorphologyMorphology computes the base form of English words, by removing just inflections (not derivational morphology).Classedu.stanford.nlp.processJavaNlp
MUCMentionExtractorExtracts mentions from a file annotated in MUC format.Classedu.stanford.nlp.dcorefJavaNlp
MultiClassChunkEvalStatsCalculates phrase based precision and recall (similar to conlleval) Handles various encodings such as IO, IOB, IOE, BILOU, SBEIO, []Classedu.stanford.nlp.statsJavaNlp
MultiCoreMapNodePatternPattern for matching across multiple core maps.Classedu.stanford.nlp.ling.tokensregexJavaNlp
MulticoreWrapperProvides convenient multicore processing for threadsafe objects.Classedu.stanford.nlp.util.concurrentJavaNlp
MulticoreWrapperDemoIllustrates simple multithreading of threadsafe objects.Classedu.stanford.nlp.tagger.maxent.documentationJavaNlp
MultiNodePatternMatches potentially multiple node (i.Classedu.stanford.nlp.ling.tokensregexJavaNlp
MultiTokenTagRepresents a tag for a multi token expression Can be used to annotate individual tokens withoutClassedu.stanford.nlp.lingJavaNlp
MutableDoubleA class for Double objects that you can change.Classedu.stanford.nlp.utilJavaNlp
MutableIntegerA class for Integer objects that you can change.Classedu.stanford.nlp.utilJavaNlp
MutableLongA class for Long objects that you can change.Classedu.stanford.nlp.utilJavaNlp
MWEPreprocessorVarious modifications to the MWEs in the
NaiveBayesClassifierA Naive Bayes classifier with a fixed number of features.Classedu.stanford.nlp.classifyJavaNlp
NaiveBayesClassifierFactoryCreates a NaiveBayesClassifier given an RVFDataset.Classedu.stanford.nlp.classifyJavaNlp
NamedDependencyAn individual dependency between a head and a dependent.Classedu.stanford.nlp.treesJavaNlp
NameMatchUse name matcher - match full names onlyAuthor:Angel ChangSee Also:Serialized FormClassedu.stanford.nlp.hcoref.sieveJavaNlp
NameMatchPreciseUse name matcher - more precise matchAuthor:Angel ChangSee Also:Serialized FormClassedu.stanford.nlp.hcoref.sieveJavaNlp
NaturalLogicAnnotationsA collection of CoreAnnotations for various Natural Logic data.Classedu.stanford.nlp.naturalliJavaNlp
NaturalLogicAnnotatorAn annotator marking operators with their scope.Classedu.stanford.nlp.naturalliJavaNlp
NaturalLogicRelationenum NaturalLogicRelationThe catalog of the seven Natural Logic relations.Classedu.stanford.nlp.naturalliJavaNlp
NaturalLogicWeightsAn encapsulation of the natural logic weights to use during forward inference.Classedu.stanford.nlp.naturalliJavaNlp
NBLinearClassifierFactoryProvides a medium-weight implementation of Bernoulli (or binary) Naive Bayes via a linear classifier.Classedu.stanford.nlp.classifyJavaNlp
NegraHeadFinderHeadFinder for the Negra
NegraPennLanguagePackLanguage pack for Negra and Tiger treebanks after conversion toAuthor:Roger Levy, Spence GreenSee Also:Serialized
NegraPennTreebankParserParamsParameter file for parsing the Penn Treebank format of the Negra Treebank (German).Classedu.stanford.nlp.parser.lexparserJavaNlp
NegraPennTreeNormalizerTree normalizer for Negra Penn Treebank
NegraPennTreeReaderFactoryA TreeReaderFactory for the Negra and Tiger treebanks in their Penn Treebank compatible export
NERClassifierCombinerSubclass of ClassifierCombiner that behaves like a NER, by copying the AnswerAnnotation labels to NERAnnotation.Classedu.stanford.nlp.ieJavaNlp
NERCombinerAnnotatorThis class will add NER information to an Annotation using a combination of NER models.Classedu.stanford.nlp.pipelineJavaNlp
NERDemoThis is a demo of calling CRFClassifier
NERFeatureFactoryFeatures for Named Entity Recognition.Classedu.stanford.nlp.ieJavaNlp
NERGUIA GUI for Named Entity sequence
NERServerA named-entity recognizer server for Stanford's NER.Classedu.stanford.nlp.ieJavaNlp
NeuralUtilsIncludes a bunch of utility methods usable by projects which use RNN, such as the parser and sentiment models.Classedu.stanford.nlp.neuralJavaNlp
NewlineLogFormatterSimply format and put a newline after each log message.Classedu.stanford.nlp.util.loggingJavaNlp
NodePatternMatches a Node (i.Classedu.stanford.nlp.ling.tokensregexJavaNlp
NoEmptiesCTBTreeReaderFactoryA CTB TreeReaderFactory that deletes empty
NoPunctuationHeadFinderSimple variant of the ModCollinsHeadFinder avoids supplying punctuation tags as heads whenever
NPTmpRetainingTreeNormalizerSame TreeNormalizer as BobChrisTreeNormalizer, but optionally provides four extras.Classedu.stanford.nlp.treesJavaNlp
NullOutputStreamAn OutputStream which throws away all output instead of outputting anything Taken from http://stackoverflow.Classedu.stanford.nlp.ioJavaNlp
NumberMatchingRegexThis file includes a regular expression to match numbers.Classedu.stanford.nlp.mathJavaNlp
NumberNormalizerProvides functions for converting words to numbers Unlike QuantifiableEntityNormalizer that normalizes variousClassedu.stanford.nlp.ieJavaNlp
NumberRangeFileFilter determine acceptance.Classedu.stanford.nlp.ioJavaNlp
NumberRangesFileFilter determine acceptance.Classedu.stanford.nlp.ioJavaNlp
NumberSequenceClassifierA set of deterministic rules for marking certain entities, to add categories and to correct for failures of statistical NER
ObjectBankThe ObjectBank class is designed to make it easy to change the format/source of data read in by other classes and to standardize how data is read inClassedu.stanford.nlp.objectbankJavaNlp
ObjectBankWrapperThis class is used to wrap the ObjectBank used by the sequence models and is where any sort of general processing, like the IOB mappingClassedu.stanford.nlp.sequencesJavaNlp
OpenIE An OpenIE system based on valid Natural Logic deletions of a sentence.Classedu.stanford.nlp.naturalliJavaNlp
OpenPageDialogSimple dialog to ask user for urlAuthor:Huy NguyenSee Also:Serialized
OperatorA collection of quantifiers.Classedu.stanford.nlp.naturalliJavaNlp
OperatorSpecA silly little class to denote a quantifier scope.Classedu.stanford.nlp.naturalliJavaNlp
OptionsThis class contains options to the parser which MUST be the SAME at both training and testing (parsing) time in order for the parser toClassedu.stanford.nlp.parser.lexparserJavaNlp
OrderedCombinationTreeNormalizerThis class combines multiple tree normalizers.Classedu.stanford.nlp.treesJavaNlp
OutputHandlerAn abstract handler incorporating the logic of outputing a log message, to some source.Classedu.stanford.nlp.util.loggingJavaNlp
PaddedListA PaddedList wraps another list, presenting an apparently infinite list by padding outside the real confines of the list with a defaultClassedu.stanford.nlp.utilJavaNlp
PairPair is a Class for holding mutable pairs of objects.Classedu.stanford.nlp.utilJavaNlp
PairsHolderA simple class that maintains a list of WordTag pairs which are interned as they are added.Classedu.stanford.nlp.tagger.maxentJavaNlp
ParentAnnotationStatsSee what parent annotation helps in treebank, based on support andVersion:2003/01/04Author:Christopher ManningClassedu.stanford.nlp.parser.lexparserJavaNlp
ParseExceptionThis exception is thrown when parse errors are encountered.Classedu.stanford.nlp.ling.tokensregex.parserJavaNlp
ParseExceptionThis exception is thrown when parse errors are encountered.Classedu.stanford.nlp.semgraph.semgrexJavaNlp
ParseExceptionThis exception is thrown when parse errors are encountered.Classedu.stanford.nlp.trees.tregexJavaNlp
ParseExceptionThis exception is thrown when parse errors are encountered.Classedu.stanford.nlp.trees.tregex.tsurgeonJavaNlp
ParseFilesRuns the parser over a set of files.Classedu.stanford.nlp.parser.lexparserJavaNlp
ParserThe interface for parser objects.Interfaceedu.stanford.nlp.parserJavaNlp
ParserA simple GUI app for Parsing.Classedu.stanford.nlp.parser.uiJavaNlp
ParserAnnotationsParse time options for the Stanford lexicalized parser.Classedu.stanford.nlp.parser.commonJavaNlp
ParserAnnotatorThis class will add parse information to an Annotation.Classedu.stanford.nlp.pipelineJavaNlp
ParserConstraintA Constraint represents a restriction on possible parse trees to consider.Classedu.stanford.nlp.parser.commonJavaNlp
ParserGrammarAn interface for the classes which store the data for a parser.Classedu.stanford.nlp.parser.commonJavaNlp
ParserPanelProvides a simple GUI Panel for Parsing.Classedu.stanford.nlp.parser.uiJavaNlp
ParserUtilsFactor out some useful methods more than lexparser module may want.Classedu.stanford.nlp.parser.commonJavaNlp
ParsingSystemDefines a transition-based parsing framework for dependency parsing.Classedu.stanford.nlp.parser.nndepJavaNlp
ParsingThreadsafeProcessorTakes a sentence and returns a ParserQuery with the given sentence parsed.Classedu.stanford.nlp.parser.commonJavaNlp
PatternAn abstract class to represent a Pattern.Classedu.stanford.nlp.patternsJavaNlp
PatternFactoryCreated by sonalg on 10/27/14.Classedu.stanford.nlp.patternsJavaNlp
PatternsForEachTokenCreated by Sonal Gupta on 10/8/14.Classedu.stanford.nlp.patterns.surfaceJavaNlp
PatternsForEachTokenDBCreated by sonalg on 10/22/14.Classedu.stanford.nlp.patterns.surfaceJavaNlp
PatternsForEachTokenInMemoryCreated by sonalg on 10/22/14.Classedu.stanford.nlp.patterns.surfaceJavaNlp
PatternTokenClass to represent a target phrase.Classedu.stanford.nlp.patterns.surfaceJavaNlp
PennTreebankLanguagePackSpecifies the treebank/language specific components needed for parsing the English Penn Treebank.Classedu.stanford.nlp.treesJavaNlp
PennTreebankTokenizerBuilds a tokenizer for English PennTreebank (release 2) trees.Classedu.stanford.nlp.treesJavaNlp
PennTreeReaderThis class implements the TreeReader interface to read Penn Treebank-style files.Classedu.stanford.nlp.treesJavaNlp
PennTreeReaderFactoryVends PennTreeReader objects.Classedu.stanford.nlp.treesJavaNlp
PhraseTableTable used to lookup multi-word phrases.Classedu.stanford.nlp.ling.tokensregexJavaNlp
PlainTextDocumentReaderAndWriterThis class provides methods for reading plain text documents and writing out those documents once classified in several different formats.Classedu.stanford.nlp.sequencesJavaNlp
PointerA pointer to an object, to get around not being able to access non-final variables within an anonymous function.Classedu.stanford.nlp.utilJavaNlp
Polarity A class intended to be attached to a lexical item, determining what mutations are valid on it while maintaining valid Natural Logic inference.Classedu.stanford.nlp.naturalliJavaNlp
POSTaggerAnnotatorWrapper for the maxent part of speech tagger.Classedu.stanford.nlp.pipelineJavaNlp
PRCurveA class to create recall-precision curves given scores used to fit the best monotonic function for logistic regression and SVMs.Classedu.stanford.nlp.classifyJavaNlp
PrecisionRecallStatsUtility class for aggregating counts of true positives, false positives, and false negatives and computing precision/recall/F1 stats.Classedu.stanford.nlp.statsJavaNlp
PreferencesManages storage and retrieval of application preferences.Classedu.stanford.nlp.trees.tregex.guiJavaNlp
PreferencesPanelClass for creating the preferences panel which holds user definable preferences (e.Classedu.stanford.nlp.trees.tregex.guiJavaNlp
PreprocessorCoref document preprocessor.Classedu.stanford.nlp.hcorefJavaNlp
PrettyLoggableIndicates that a class supports "pretty logging".Interfaceedu.stanford.nlp.util.loggingJavaNlp
PrettyLoggerPrimarily for debugging, PrettyLogger helps you dump various collection objects in a reasonably structured way via Redwood logging.Classedu.stanford.nlp.util.loggingJavaNlp
PrintFileShorthand class for opening an output file for human-readable output.Classedu.stanford.nlp.ioJavaNlp
PriorityQueueA Set that also represents an ordering of its elements, and responds quickly to add(), changePriority(),Interfaceedu.stanford.nlp.utilJavaNlp
ProbabilisticClassifierCreatorCreates a probablic classifier with given weightscreateProbabilisticClassifierInterfaceedu.stanford.nlp.classifyJavaNlp
ProbabilityDistributionThis is an interface for probability measures, which will allow samples to be drawn and the probability of objects computed.Interfaceedu.stanford.nlp.statsJavaNlp
ProblemThis is a general class for a Problem to be solved by the MaxEnt toolkit.Classedu.stanford.nlp.maxentJavaNlp
PropertiesUtilsUtilities methods for standard (but woeful) Java Properties objects.Classedu.stanford.nlp.utilJavaNlp
ProtobufAnnotationSerializer A serializer using Google's protocol buffer format.Classedu.stanford.nlp.pipelineJavaNlp
PTBEscapingProcessorProduces a new Document of Words in which special characters of the PTB have been properly escaped.Classedu.stanford.nlp.processJavaNlp
PTBTokenizerA fast, rule-based tokenizer implementation, which produces Penn Treebank style tokenization of English text.Classedu.stanford.nlp.processJavaNlp
PunctEquivalenceClasserPerforms equivalence classing of punctuation per PTB guidelines.Classedu.stanford.nlp.parser.toolsJavaNlp
QNMinimizerAn implementation of L-BFGS for Quasi Newton unconstrained minimization.Classedu.stanford.nlp.optimizationJavaNlp
QPTreeTransformerTransforms an English structure parse tree in order to get the dependencies right: Adds an extra structure in QP phrases:Classedu.stanford.nlp.treesJavaNlp
QuadrupleA quadruple of ordered objects.Classedu.stanford.nlp.utilJavaNlp
QuantifiableEntityNormalizerVarious methods for normalizing Money, Date, Percent, Time, and Number, Ordinal amounts.Classedu.stanford.nlp.ieJavaNlp
QuasiDeterminizerQuasiDeterminizer performing quasi-determinization on TransducerGraphs.Classedu.stanford.nlp.fsmJavaNlp
QuoteAnnotatorAn annotator which picks quotations out of the given text.Classedu.stanford.nlp.pipelineJavaNlp
RadicalMapA way to determine the primary (or "semantic") radical of a Chinese character or get the set of characters with a given semantic
ReadDataTaggedReads tagged data from a file and creates a dictionary.Classedu.stanford.nlp.tagger.maxentJavaNlp
ReaderInputStreamAdapts a Reader as an InputStream.Classedu.stanford.nlp.ioJavaNlp
ReaderIteratorFactoryA ReaderIteratorFactory provides a means of getting an Iterator which returns java.Classedu.stanford.nlp.objectbankJavaNlp
ReadSentimentDatasetReads the sentiment dataset and writes it to the appropriate files.Classedu.stanford.nlp.sentimentJavaNlp
RecursiveTreeTransformerA tool to recursively alter a tree in various ways.Classedu.stanford.nlp.treesJavaNlp
RedirectOutputHandlerA class to redirect the output of Redwood to another logging mechanism, e.Classedu.stanford.nlp.util.loggingJavaNlp
RedwoodA hierarchical channel based logger.Classedu.stanford.nlp.util.loggingJavaNlp
RedwoodConfigurationA class which encapsulates configuration settings for Redwood.Classedu.stanford.nlp.util.loggingJavaNlp
RedwoodPrintStreamA PrintStream that writes to Redwood logs.Classedu.stanford.nlp.util.loggingJavaNlp
ReflectionLoadingThe goal of this class is to make it easier to load stuff by reflection.Classedu.stanford.nlp.utilJavaNlp
RegExFileFilter Preciesly, it will accept exactly those Files for which the matches() method of the Pattern returns true on the output of the getName()Classedu.stanford.nlp.ioJavaNlp
RegexNERAnnotatorThis class adds NER information to an annotation using the RegexNERSequenceClassifier.Classedu.stanford.nlp.pipelineJavaNlp
RegexNERSequenceClassifierA sequence classifier that labels tokens with types based on a simple manual mapping from regular expressions to the types of the entities they are meant to
RegexStringFilterFilters Strings based on whether they match a given regex.Classedu.stanford.nlp.utilJavaNlp
RelationExtractorAnnotatorAnnotating relations between entities produced by the NER system.Classedu.stanford.nlp.pipelineJavaNlp
RelationFeatureFactoryBase class for feature factories Created by Sonal
RelationMentionEach relation has a type and set of argumentsAuthor:Andrey Gusev, Mihai, David McCloskySee Also:Serialized
RelationTripleA (subject, relation, object) triple;
RelationTripleSegmenterThis class takes a SentenceFragment and converts it to a conventional OpenIE triple, as materialized in the RelationTriple class.Classedu.stanford.nlp.naturalliJavaNlp
ReorderingOracleA second attempt at making an oracle.Classedu.stanford.nlp.parser.shiftreduceJavaNlp
RepeatedRecordHandlerFilters repeated messages and replaces them with the number of times they were logged.Classedu.stanford.nlp.util.loggingJavaNlp
RequirementStores and describes a set of requirements for the typical use of the pipeline.Classedu.stanford.nlp.pipelineJavaNlp
RerankerA scorer which the RerankingParserQuery can use to rescore sentences.Interfaceedu.stanford.nlp.parser.lexparserJavaNlp
RerankerQueryProcess a Tree and return a score.Interfaceedu.stanford.nlp.parser.lexparserJavaNlp
RerankingParserQueryRerank trees from the ParserQuery based on scores from a Reranker.Classedu.stanford.nlp.parser.lexparserJavaNlp
ResettableReaderIteratorFactoryVends ReaderIterators which can always be rewound.Classedu.stanford.nlp.objectbankJavaNlp
ResultsPrinterClass for comparing the output of information extraction to a gold standard, and printing the
RNNTestOptionsEvaluation-only options for the RNN modelsAuthor:John BauerSee Also:Serialized FormClassedu.stanford.nlp.sentimentJavaNlp
RuleInterface for int-format grammar rules.Interfaceedu.stanford.nlp.parser.lexparserJavaNlp
RulesRules for coref system (mention detection, entity coref, event coref) The name of the method for mention detection starts with detection,Classedu.stanford.nlp.dcorefJavaNlp
RulesRules for coref system (mention detection, entity coref, event coref) The name of the method for mention detection starts with detection,Classedu.stanford.nlp.hcorefJavaNlp
RuntimeInterruptedExceptionAn unchecked version of InterruptedException.Classedu.stanford.nlp.utilJavaNlp
RuntimeIOExceptionAn unchecked version of IOException.Classedu.stanford.nlp.ioJavaNlp
RVFClassifierA simple interface for classifying and scoring data points with real-valued features.Interfaceedu.stanford.nlp.classifyJavaNlp
RVFDatasetAn interfacing class for ClassifierFactory that incrementally builds a more memory-efficient representation of a List of RVFDatumClassedu.stanford.nlp.classifyJavaNlp
RVFDatumA basic implementation of the Datum interface that can be constructed with a Collection of features and one more more labels.Classedu.stanford.nlp.lingJavaNlp
SamplerAn interace for drawing samples from the label space of an object.Interfaceedu.stanford.nlp.statsJavaNlp
ScaledSGDMinimizerStochastic Gradient Descent To Quasi Newton Minimizer.Classedu.stanford.nlp.optimizationJavaNlp
ScoredScored: This is a simple interface that says that an object can answer requests for the score, or goodness of the object.Interfaceedu.stanford.nlp.utilJavaNlp
ScoredComparatorScoredComparator allows one to compare Scored things.Classedu.stanford.nlp.utilJavaNlp
ScoredObjectWrapper class for holding a scored object.Classedu.stanford.nlp.utilJavaNlp
ScorePatternsF1Used if patternScoring flag is set to F1 with the seed pattern.Classedu.stanford.nlp.patterns.surfaceJavaNlp
ScorePhrasesAverageFeaturesScore phrases by averaging scores of individual features.Classedu.stanford.nlp.patternsJavaNlp
ScorerInterface for supporting A* scoring.Interfaceedu.stanford.nlp.parser.lexparserJavaNlp
ScrollableTreeJPanelComponent for displaying a tree in a JPanel that works correctly withAuthor:Anna RaffertySee Also:Serialized FormClassedu.stanford.nlp.trees.tregex.guiJavaNlp
SemanticGraphRepresents a semantic graph of a sentence or document, with IndexedWord The root is not at present represented as a vertex in the graph.Classedu.stanford.nlp.semgraphJavaNlp
SemanticGraphCoreAnnotationsThis class collects CoreAnnotations that are used in working with a SemanticGraph.Classedu.stanford.nlp.semgraphJavaNlp
SemanticGraphEdgeRepresents an edge in the dependency graph.Classedu.stanford.nlp.semgraphJavaNlp
SemanticGraphFactoryRefactoring of static makers of SemanticGraphs in order to simplify the SemanticGraph class.Classedu.stanford.nlp.semgraphJavaNlp
SemanticGraphFormatterDefines a class for pretty-printing SemanticGraphs.Classedu.stanford.nlp.semgraphJavaNlp
SemanticGraphUtilsGeneric utilities for dealing with Dependency graphs and other structures, useful for text simplification and rewriting.Classedu.stanford.nlp.semgraphJavaNlp
SemanticHeadFinder found in Michael Collins' 1999 thesis.Classedu.stanford.nlp.treesJavaNlp
SemgrexMatcherA SemgrexMatcher can be used to match a SemgrexPattern against a SemanticGraph.Classedu.stanford.nlp.semgraph.semgrexJavaNlp
SemgrexParseExceptionA runtime exception that indicates something went wrong parsing a semgrex expression.Classedu.stanford.nlp.semgraph.semgrexJavaNlp
SemgrexPatternA SemgrexPattern is a tgrep-type pattern for matching node configurations in one of the SemanticGraph structures.Classedu.stanford.nlp.semgraph.semgrexJavaNlp
SemiSupervisedLogConditionalObjectiveFunctionMaximizes the conditional likelihood with a given prior.Classedu.stanford.nlp.classifyJavaNlp
SentenceSentence holds a couple utility methods for lists.Classedu.stanford.nlp.lingJavaNlp
SentenceA representation of a single Sentence.Classedu.stanford.nlp.simpleJavaNlp
SentenceAlgorithms A set of common utility algorithms for working with sentences (e.Classedu.stanford.nlp.simpleJavaNlp
SentenceAnnotatorA parent class for annotators which might want to analyze one sentence at a time, possibly in a multithreaded manner.Classedu.stanford.nlp.pipelineJavaNlp
SentenceFragmentA representation of a sentence fragment.Classedu.stanford.nlp.naturalliJavaNlp
SentenceIndexCreated by sonalg on 10/15/14.Classedu.stanford.nlp.patternsJavaNlp
SentimentAnnotatorThis annotator attaches a binarized tree with sentiment annotations to each sentence.Classedu.stanford.nlp.pipelineJavaNlp
SentimentCoreAnnotationsAnnotations specific to the Sentiment project.Classedu.stanford.nlp.sentimentJavaNlp
SentimentPipelineA wrapper class which creates a suitable pipeline for the sentiment model and processes raw text.Classedu.stanford.nlp.sentimentJavaNlp
SentimentUtilsIn the Sentiment dataset converted to tree form, the labels on the intermediate nodes are the sentiment scores and the leaves are theClassedu.stanford.nlp.sentimentJavaNlp
SeqClassifierFlagsFlags for sequence classifiers.Classedu.stanford.nlp.sequencesJavaNlp
SequenceGibbsSamplerA Gibbs sampler for sequence models.Classedu.stanford.nlp.sequencesJavaNlp
SequenceListenerA class capable of listening to changes about a sequence, represented as an array of type int.Interfaceedu.stanford.nlp.sequencesJavaNlp
SequenceMatcherA generic sequence matcher.Classedu.stanford.nlp.ling.tokensregexJavaNlp
SequenceMatchResultThe result of a match against a sequence.Interfaceedu.stanford.nlp.ling.tokensregexJavaNlp
SequenceMatchRulesRules for matching sequences using regular expressions There are 2 types of rules:Classedu.stanford.nlp.ling.tokensregexJavaNlp
SequenceModelInterface for scoring the labeling of sequences of a fixed length.Interfaceedu.stanford.nlp.sequencesJavaNlp
SequencePatternGeneric Sequence Pattern for regular expressions.Classedu.stanford.nlp.ling.tokensregexJavaNlp
SequenceSamplerThis class will sample an output from a sequence model.Classedu.stanford.nlp.sequencesJavaNlp
SerializableFunctionThis interface is a conjunction of Function and Serializable, which is a bad idea from the perspective of the type system, but one that seemsInterfaceedu.stanford.nlp.processJavaNlp
SGDMinimizerIn place Stochastic Gradient Descent Minimizer.Classedu.stanford.nlp.optimizationJavaNlp
SGDToQNMinimizerStochastic Gradient Descent To Quasi Newton Minimizer An experimental minimizer which takes a stochastic function (one implementing AbstractStochasticCachingDiffFunction)Classedu.stanford.nlp.optimizationJavaNlp
SGDWithAdaGradAndFOBOSStochastic Gradient Descent With AdaGrad and FOBOS in batch mode.Classedu.stanford.nlp.optimizationJavaNlp
ShiftReduceParserA shift-reduce constituency parser.Classedu.stanford.nlp.parser.shiftreduceJavaNlp
ShiftTransitionTransition that moves a single item from the front of the queue to the top of the stack without making any other changes.Classedu.stanford.nlp.parser.shiftreduceJavaNlp
SieveCoreferenceSystemMulti-pass Sieve coreference resolution system (see EMNLP 2010 paper).Classedu.stanford.nlp.dcorefJavaNlp
Sighan2005DocumentReaderAndWriterDocumentReader for Chinese segmentation task.Classedu.stanford.nlp.wordsegJavaNlp
SimpleConstituentA SimpleConstituent object defines a generic edge in a graph.Classedu.stanford.nlp.treesJavaNlp
SimpleConstituentFactoryA ConstituentFactory acts as a factory for creating objects of class Constituent, or some descendent class.Classedu.stanford.nlp.treesJavaNlp
SimpleGoodTuringSimple Good-Turing smoothing, based on code from Sampson, available at: ftp://ftp.Classedu.stanford.nlp.statsJavaNlp
SimpleTensorThis class defines a block tensor, somewhat like a three dimensional matrix.Classedu.stanford.nlp.neuralJavaNlp
SimpleTreeA SimpleTree is a minimal concrete implementation of an unlabeled, unscored Tree.Classedu.stanford.nlp.treesJavaNlp
SimpleTreeFactoryA SimpleTreeFactory acts as a factory for creating objects of class SimpleTree.Classedu.stanford.nlp.treesJavaNlp
SisterAnnotationStatsSee what sister annotation helps in treebank, based on support and KL divergence.Classedu.stanford.nlp.parser.lexparserJavaNlp
SloppyMathThe class SloppyMath contains methods for performing basic numeric operations.Classedu.stanford.nlp.mathJavaNlp
SMDMinimizer Stochastic Meta Descent Minimizer based on Accelerated training of conditional random fields with stochastic gradient methodsClassedu.stanford.nlp.optimizationJavaNlp
SpanStores the offsets for a span of text Offsets may indicate either token or byte
SpanA Span is an optimized SimpleConstituent object.Classedu.stanford.nlp.treesJavaNlp
SpanishTokenizerTokenizer for raw Spanish
SpanishTreebankLanguagePackLanguage pack for the Spanish
SpanishTreebankParserParamsTreebankLangParserParams for the AnCora corpus.Classedu.stanford.nlp.parser.lexparserJavaNlp
SpanishTreeNormalizerNormalize trees read from the AnCora Spanish
SpanishTreeReaderFactoryA class for reading Spanish AnCora trees that have been converted from XML to PTB
SpanishUnknownWordSignaturesContains patterns for matching certain word types in Spanish, such as common suffices for nouns, verbs, adjectives and
SpanishVerbStripperProvides a utility function for removing attached pronouns from Spanish verb
SpeakerInfoInformation about a speakerAuthor:Angel ChangSee Also:Serialized FormClassedu.stanford.nlp.hcoref.dataJavaNlp
SplittingGrammarExtractorThis class is a reimplementation of Berkeley's state splitting grammar.Classedu.stanford.nlp.parser.lexparserJavaNlp
SQLConnectionCreated by sonalg on 10/8/14.Classedu.stanford.nlp.patternsJavaNlp
SQNMinimizerOnline Limited-Memory Quasi-Newton BFGS implementation based on the algorithms in Nocedal, Jorge, and Stephen J.Classedu.stanford.nlp.optimizationJavaNlp
StanfordCoreNLPThis is a pipeline that takes in a string and returns various analyzed The String is tokenized via a tokenizer (using a TokenizerAnnotator), andClassedu.stanford.nlp.pipelineJavaNlp
StanfordCoreNLPClientAn annotation pipeline in spirit identical to StanfordCoreNLP, but with the backend supported by a web server.Classedu.stanford.nlp.pipelineJavaNlp
StanfordCoreNLPServerThis class creates a server that runs a new Java annotator in each thread.Classedu.stanford.nlp.pipelineJavaNlp
StartAndEndArabicSegmenterFeatureFactoryFeature factory for the IOB clitic segmentation model described by Green and DeNero (2012)
StateA class which encodes the current state of the parsing.Classedu.stanford.nlp.parser.shiftreduceJavaNlp
StochasticCalculateMethodsenum StochasticCalculateMethodsThis enumeratin was created to organize the selection of different methods for stochasticClassedu.stanford.nlp.optimizationJavaNlp
StochasticMinimizerStochastic Gradient Descent Minimizer.Classedu.stanford.nlp.optimizationJavaNlp
StreamGobblerReads the output of a process started by Process.Classedu.stanford.nlp.utilJavaNlp
StringLabelA StringLabel object acts as a Label by containing a single String, which it sets or returns in response to requests.Classedu.stanford.nlp.lingJavaNlp
StringLabeledScoredTreeReaderFactoryThis class implements a TreeReaderFactory that produces labeled, scored array-based Trees, which have been cleaned up toClassedu.stanford.nlp.treesJavaNlp
StringLabelFactoryA StringLabelFactory object makes a simple StringLabel out of a String.Classedu.stanford.nlp.lingJavaNlp
StringOutputStreamAn OutputStream that can be turned into a String.Classedu.stanford.nlp.ioJavaNlp
StringParsingTaskAn instantiation of this abstract class parses a String and returns an object of type E.Classedu.stanford.nlp.utilJavaNlp
StringUtilsStringUtils is a class for random String things, including output formatting and command line argument parsing.Classedu.stanford.nlp.utilJavaNlp
StripTagsProcessorA Processor whose process method deletes all SGML/XML/HTML tags (tokens starting with < and endingClassedu.stanford.nlp.processJavaNlp
StyleANSI supported styles (rather, a subset of) These values are mirrored in Redwood.Classedu.stanford.nlp.util.loggingJavaNlp
SunJurafskyChineseHeadFinderA HeadFinder for Chinese based on rules described in Sun/Jurafsky NAACL
SurfacePatternTo represent a surface pattern in more detail than TokenSequencePattern (this class object is eventually compiled as TokenSequencePattern via the toStringClassedu.stanford.nlp.patterns.surfaceJavaNlp
SurfacePatternFactoryCreated by sonalg on 10/27/14.Classedu.stanford.nlp.patterns.surfaceJavaNlp
SUTimeSUTime is a collection of data structures to represent various temporal concepts and operations between them.Classedu.stanford.nlp.timeJavaNlp
SUTimeMainMain program for testing SUTime Processing a text string:Classedu.stanford.nlp.timeJavaNlp
SVMLightClassifierThis class represents a trained SVM Classifier.Classedu.stanford.nlp.classifyJavaNlp
SVMLightClassifierFactoryThis class is meant for training SVMs (SVMLightClassifiers).Classedu.stanford.nlp.classifyJavaNlp
SynchronizedInterner For interning (canonicalizing) things in a multi-threaded environment.Classedu.stanford.nlp.util.concurrentJavaNlp
SynchronizedTreeTransformerIf you have a TreeTransformer which is not threadsafe, and you need to call it from multiple threads, this will wrap it in aClassedu.stanford.nlp.treesJavaNlp
SystemUtilsUseful methods for running shell commands, getting the process ID, checkingAuthor:Bill MacCartney, Steven Bethard (run(java.Classedu.stanford.nlp.utilJavaNlp
TagA Tag object acts as a Label by containing a String that is a part-of-speech tag.Classedu.stanford.nlp.lingJavaNlp
TaggedFileRecordParses and specifies all the details for how to read some POS tagging data.Classedu.stanford.nlp.tagger.ioJavaNlp
TaggedWordA TaggedWord object contains a word and its tag.Classedu.stanford.nlp.lingJavaNlp
TaggedWordFactoryA TaggedWordFactory acts as a factory for creating objects ofVersion:2000/12/21Author:Christopher ManningClassedu.stanford.nlp.lingJavaNlp
TaggerThis module includes constants that are the same for all taggers, as opposed to being part of their configurations.Classedu.stanford.nlp.tagger.commonJavaNlp
TaggerConfigReads and stores configuration information for a POS tagger.Classedu.stanford.nlp.tagger.maxentJavaNlp
TaggerExperimentsThis class represents the training samples.Classedu.stanford.nlp.tagger.maxentJavaNlp
TaggerFeatureHolds a Tagger Feature for the loglinear model.Classedu.stanford.nlp.tagger.maxentJavaNlp
TaggerFeaturesThis class contains POS tagger specific features.Classedu.stanford.nlp.tagger.maxentJavaNlp
TaggingEvalComputes POS tagging P/R/F1 from guess/gold trees.Classedu.stanford.nlp.parser.metricsJavaNlp
TagProjectionAn interface for projecting POS tags onto a reduced set for the dependency grammar.Interfaceedu.stanford.nlp.parser.lexparserJavaNlp
TagsTags that can be added to values or annotationsSee Also:Serialized FormClassedu.stanford.nlp.ling.tokensregex.typesJavaNlp
TdiffExtracts the differences between the sets of constituents indicated by a pair of parse trees.Classedu.stanford.nlp.trees.tregex.guiJavaNlp
TestClassifierTags data and can handle either data with gold-standard tags (computing performance statistics) or unlabeled data.Classedu.stanford.nlp.tagger.maxentJavaNlp
TestOptionsOptions to the parser which affect performance only at testing (parsing) The Options class that stores the TestOptions stores theClassedu.stanford.nlp.parser.lexparserJavaNlp
TestSequenceModelFor sequence model inference at
ThreadsafeProcessorObjects that wish to use MulticoreWrapper for multicore support must implement this interface.Interfaceedu.stanford.nlp.util.concurrentJavaNlp
TimeAnnotationsSet of common annotations for CoreMaps that require classes from the time package.Classedu.stanford.nlp.timeJavaNlp
TimeAnnotatorAnnotate temporal expressions in text with SUTime.Classedu.stanford.nlp.timeJavaNlp
TimeExpressionExtractorA TimeExpressionExtractor extracts a list of time expressions from a document annotation.Interfaceedu.stanford.nlp.timeJavaNlp
TimeExpressionExtractorFactoryFactory for creating TimeExpressionExtractorAuthor:Angel ChangSee Also:Serialized FormClassedu.stanford.nlp.timeJavaNlp
TimeExpressionExtractorImplExtracts time expressions.Classedu.stanford.nlp.timeJavaNlp
TimeExpressionPatternsInterface for rules/patterns for transforming time related natural language expressionsInterfaceedu.stanford.nlp.timeJavaNlp
TimexStores one TIMEX3 expression.Classedu.stanford.nlp.timeJavaNlp
TimingA class for measuring how long things take.Classedu.stanford.nlp.utilJavaNlp
TokenCurrently can handle only ORs Created by sonalg on 10/16/14.Classedu.stanford.nlp.patterns.surfaceJavaNlp
TokenizerTokenizers break up text into individual Objects.Interfaceedu.stanford.nlp.processJavaNlp
TokenizerAdapterThis class adapts between a java.Classedu.stanford.nlp.processJavaNlp
TokenizerAnnotatorThis class will PTB tokenize the input.Classedu.stanford.nlp.pipelineJavaNlp
TokenizerFactoryA TokenizerFactory is used to convert a java.Interfaceedu.stanford.nlp.processJavaNlp
TokenSequenceParseExceptionCreated by sonalg on 2/5/15.Classedu.stanford.nlp.ling.tokensregex.parserJavaNlp
TokenSequencePatternToken Sequence Pattern for regular expressions over sequences of tokens (each represented as a CoreMap).Classedu.stanford.nlp.ling.tokensregexJavaNlp
TokensRegexAnnotatorUses TokensRegex patterns to annotate tokens.Classedu.stanford.nlp.pipelineJavaNlp
TokensRegexNERAnnotator TokensRegexNERAnnotator labels tokens with types based on a simple manual mapping from regular expressions to the types of the entities they are meant to describe.Classedu.stanford.nlp.pipelineJavaNlp
TooltipJListSimple list class that extends JList and adds tool tip functionality to the list.Classedu.stanford.nlp.swingJavaNlp
TopNGramRecordThis class stores the best K ngrams for each class for a model.Classedu.stanford.nlp.neural.rnnJavaNlp
TrainOptionsNon-language-specific options for training a grammar from a treebank.Classedu.stanford.nlp.parser.lexparserJavaNlp
TransducerGraphTransducerGraph represents a deterministic finite state automaton without epsilon transitions.Classedu.stanford.nlp.fsmJavaNlp
TransformingTreebankThis class wraps another Treebank, and will vend trees that have been through a TreeTransformer.Classedu.stanford.nlp.treesJavaNlp
TransformXMLReads XML from an input file or stream and writes XML to an output file or stream, while transforming text appearing inside specifiedClassedu.stanford.nlp.processJavaNlp
TransitionAn interface which defines a transition type in the shift-reduce parser.Interfaceedu.stanford.nlp.parser.shiftreduceJavaNlp
TreeThe abstract class Tree is used to collect all of the tree types, and acts as a generic extensible type.Classedu.stanford.nlp.treesJavaNlp
TreeAnnotatorPerforms non-language specific annotation of Trees.Classedu.stanford.nlp.parser.lexparserJavaNlp
TreebankA Treebank object provides access to a corpus of examples with given tree structures.Classedu.stanford.nlp.treesJavaNlp
TreebankAnnotatorClass for getting an annotated treebank.Classedu.stanford.nlp.parser.lexparserJavaNlp
TreebankFactoryAn interface for treebank vendors.Interfaceedu.stanford.nlp.treesJavaNlp
TreebankLangParserParamsContains language-specific methods commonly necessary to get a parser to parse an arbitrary treebank.Interfaceedu.stanford.nlp.parser.lexparserJavaNlp
TreebankLanguagePackThis interface specifies language/treebank specific information for a Treebank, which a parser or other treebank user might need to know.Interfaceedu.stanford.nlp.treesJavaNlp
TreebankPreprocessorA data preparation pipeline for treebanks.Classedu.stanford.nlp.trees.treebankJavaNlp
TreebanksThis is just a main method and other static methods for command-line manipulation, statistics, and testing ofClassedu.stanford.nlp.treesJavaNlp
TreeBinarizerBinarizes trees in such a way that head-argument structure is respected.Classedu.stanford.nlp.parser.lexparserJavaNlp
TreeCollinizerDoes detransformations to a parsed sentence to map it back to the standard treebank form for output or evaluation.Classedu.stanford.nlp.parser.lexparserJavaNlp
TreeCoreAnnotationsSet of common annotations for CoreMaps that require classes from the trees package.Classedu.stanford.nlp.treesJavaNlp
TreeFactoryA TreeFactory acts as a factory for creating objects of class Tree, or some descendant class.Interfaceedu.stanford.nlp.treesJavaNlp
TreeFiltersA location for general implementations of Filter.Classedu.stanford.nlp.treesJavaNlp
TreeFromFileSimple utility class for storing a tree as well as the sentence the tree represents and a label with the filename of the file that the tree was stored in.Classedu.stanford.nlp.trees.tregex.guiJavaNlp
TreeFunctionsThis is a utility class which vends tree transformers to translate trees from one factory type to trees of another.Classedu.stanford.nlp.treesJavaNlp
TreeGraphNode A TreeGraphNode is simply a with some additional functionality.Classedu.stanford.nlp.treesJavaNlp
TreeGraphNodeFactoryA TreeGraphNodeFactory acts as a factory for creating tree nodes of type TreeGraphNode.Classedu.stanford.nlp.treesJavaNlp
TreeJPanelClass for displaying a Tree.Classedu.stanford.nlp.parser.uiJavaNlp
TreeLeafLabelTransformerApplies a Function to the labels in a tree.Classedu.stanford.nlp.treesJavaNlp
TreeLengthComparatorA TreeLengthComparator orders trees by their yield sentenceVersion:2003/03/24Author:Christopher ManningClassedu.stanford.nlp.treesJavaNlp
TreeNormalizerA class for tree normalization.Classedu.stanford.nlp.treesJavaNlp
TreePrintA class for customizing the print method(s) for a edu.Classedu.stanford.nlp.treesJavaNlp
TreeReaderA TreeReader adds functionality to another Reader by reading in Trees, or some descendant class.Interfaceedu.stanford.nlp.treesJavaNlp
TreeReaderFactoryA TreeReaderFactory is a factory for creating objects of class TreeReader, or some descendant class.Interfaceedu.stanford.nlp.treesJavaNlp
TreeRecorderOutputs either binarized or debinarized trees to a given filename.Classedu.stanford.nlp.parser.shiftreduceJavaNlp
TreesVarious static utilities for the Tree class.Classedu.stanford.nlp.treesJavaNlp
TreeShapedStackRepresents a stack where one prefix of the stack can branch in several directions.Classedu.stanford.nlp.utilJavaNlp
TreeSpanScoringProvides a method for deciding how similar two trees are.Classedu.stanford.nlp.parser.metricsJavaNlp
TreeTokenizerFactoryWrapper for TreeReaderFactory.Classedu.stanford.nlp.treesJavaNlp
TreeTransformerThis is a simple interface for a function that alters aAuthor:Christopher Manning.Interfaceedu.stanford.nlp.treesJavaNlp
TreeVisitorThis is a simple strategy-type interface for operations that are applied to Tree.Interfaceedu.stanford.nlp.treesJavaNlp
TregexGUIMain class for creating a tregex gui.Classedu.stanford.nlp.trees.tregex.guiJavaNlp
TregexMatcherA TregexMatcher can be used to match a TregexPattern against a Tree.Classedu.stanford.nlp.trees.tregexJavaNlp
TregexParseExceptionA runtime exception that indicates something went wrong parsing a tregex expression.Classedu.stanford.nlp.trees.tregexJavaNlp
TregexPatternA TregexPattern is a tgrep-type pattern for matching tree node configurations.Classedu.stanford.nlp.trees.tregexJavaNlp
TregexPatternCompilerA class for compiling TregexPatterns with specific HeadFinders and or basicCategoryFunctions.Classedu.stanford.nlp.trees.tregexJavaNlp
TregexPoweredTreebankParserParams AbstractTreebankParserParams which provides support for Tregex-powered annotations.Classedu.stanford.nlp.parser.lexparserJavaNlp
TrieMapMap that takes a iterable as key, and maps it to an value.Classedu.stanford.nlp.ling.tokensregex.matcherJavaNlp
TrieMapMatcherThe TrieMapMatcher provides functions to match against a trie.Classedu.stanford.nlp.ling.tokensregex.matcherJavaNlp
TrileanA boolean, but for three-valued logics (true / false / unknown).Classedu.stanford.nlp.utilJavaNlp
TripleClass representing an ordered triple of objects, possibly typed.Classedu.stanford.nlp.utilJavaNlp
TrueCasingForNISTDocumentReaderAndWriterA DocumentReaderAndWriter for truecasing documents.Classedu.stanford.nlp.sequencesJavaNlp
TsurgeonTsurgeon provides a way of editing trees based on a set of operations that are applied to tree locations matching a tregex pattern.Classedu.stanford.nlp.trees.tregex.tsurgeonJavaNlp
TsurgeonMatcherAn object factored out to keep the state of a Tsurgeon operation separate from the TsurgeonPattern objects.Classedu.stanford.nlp.trees.tregex.tsurgeonJavaNlp
TsurgeonParseExceptionA runtime exception that indicates something went wrong parsing a Tsurgeon expression.Classedu.stanford.nlp.trees.tregex.tsurgeonJavaNlp
TsurgeonPatternAn abstract class for patterns to manipulate Trees when successfully matched on with a TregexMatcher.Classedu.stanford.nlp.trees.tregex.tsurgeonJavaNlp
TsurgeonRuntimeExceptionSomething has gone wrong internally in TsurgeonAuthor:John BauerSee Also:Serialized FormClassedu.stanford.nlp.trees.tregex.tsurgeonJavaNlp
TTagsThis class holds the POS tags, assigns them unique ids, and knows which tags are open versus closed class.Classedu.stanford.nlp.tagger.maxentJavaNlp
TueBaDZHeadFinderA HeadFinder for TueBa-D/
TueBaDZLanguagePackLanguage pack for the Tuebingen Treebank of Written German (TueBa-D/Z)
TueBaDZParserParamsTreebankLangParserParams for the German Tuebingen corpus.Classedu.stanford.nlp.parser.lexparserJavaNlp
TueBaDZPennTreeNormalizerTree normalizer for the TueBaDZ
TwoDimensionalCollectionValuedMapA class which can store mappings from Object keys to Collections of Object values.Classedu.stanford.nlp.utilJavaNlp
TwoDimensionalCounterA class representing a mapping between pairs of typed objects and doubleAuthor:Teg GrenagerSee Also:Serialized FormClassedu.stanford.nlp.statsJavaNlp
TwoDimensionalIntCounterA class representing a mapping between pairs of typed objects and int values.Classedu.stanford.nlp.statsJavaNlp
TwoDimensionalSetWrap a TwoDimensionalMap as a TwoDimensionalSet.Classedu.stanford.nlp.utilJavaNlp
TypedDependencyA TypedDependency is a relation between two words in a GrammaticalStructure.Classedu.stanford.nlp.treesJavaNlp
TypesafeMapType signature for a class that supports the basic operations required of a typesafe heterogeneous map.Interfaceedu.stanford.nlp.utilJavaNlp
UDFeatureAnnotatorExtracts universal dependencies features from a treeAuthor:Sebastian SchusterClassedu.stanford.nlp.pipelineJavaNlp
UnaryGrammarMaintains efficient indexing of unary grammar rules.Classedu.stanford.nlp.parser.lexparserJavaNlp
UnaryRuleUnary grammar rules (with ints for parent and child).Classedu.stanford.nlp.parser.lexparserJavaNlp
UnaryTransitionTransition that makes a unary parse node in a partially finished tree.Classedu.stanford.nlp.parser.shiftreduceJavaNlp
UniversalDependenciesFeatureAnnotatorAdds lemmata and features to an English CoNLL-U dependenciesAuthor:Sebastian SchusterClassedu.stanford.nlp.trees.udJavaNlp
UniversalEnglishGrammaticalRelationsUniversalEnglishGrammaticalRelations is a set of GrammaticalRelation objects according to the UniversalClassedu.stanford.nlp.treesJavaNlp
UniversalEnglishGrammaticalStructureA GrammaticalStructure for Universal Dependencies English.Classedu.stanford.nlp.treesJavaNlp
UniversalPOSMapperMaps LDC-provided Bies mappings to the Universal POS tag set described in Slav Petrov, Dipanjan Das and Ryan
UniversalPOSMapperHelper class to perform a context-sensitive mapping of POS tags in a tree to universal POS tags.Classedu.stanford.nlp.treesJavaNlp
UniversalSemanticHeadFinder in Michael Collins' 1999 thesis.Classedu.stanford.nlp.treesJavaNlp
UnknownGTTrainerThis class trains a Good-Turing model for unknown words from a collection of trees.Classedu.stanford.nlp.parser.lexparserJavaNlp
UnknownWordModelThis class defines the runtime interface for unknown words in lexparser.Interfaceedu.stanford.nlp.parser.lexparserJavaNlp
UnknownWordModelTrainerAn interface for training an UnknownWordModel.Interfaceedu.stanford.nlp.parser.lexparserJavaNlp
UnknownWordPrinterPrints out words which are unknown to the DVParser.Classedu.stanford.nlp.parser.dvparserJavaNlp
UnlabeledAttachmentEvalDependency unlabeled attachment score.Classedu.stanford.nlp.parser.metricsJavaNlp
UnnamedConcreteDependencyAn individual dependency between a head and a dependent.Classedu.stanford.nlp.treesJavaNlp
UnnamedDependencyAn individual dependency between a head and a dependent.Classedu.stanford.nlp.treesJavaNlp
ValueAn expression that has been evaluated to a Java object of type T.Interfaceedu.stanford.nlp.ling.tokensregex.typesJavaNlp
ValueFunctionA function that takes as input an environment (Env) and a list of values (List) and returns a Value.Interfaceedu.stanford.nlp.ling.tokensregex.typesJavaNlp
ValueFunctionsValueFunctions supported by tokensregex.Classedu.stanford.nlp.ling.tokensregex.typesJavaNlp
ValueLabelA ValueLabel object acts as a Label with linguistic attributes.Classedu.stanford.nlp.lingJavaNlp
VectorMapA serializer for reading / writing word vectors.Classedu.stanford.nlp.neuralJavaNlp
VisibilityHandlerA filter for selecting which channels are visible.Classedu.stanford.nlp.util.loggingJavaNlp
ViterbiParserThe interface for Viterbi parsers.Interfaceedu.stanford.nlp.parserJavaNlp
ViterbiParserWithOptionsThe interface for Viterbi parsers with options.Interfaceedu.stanford.nlp.parserJavaNlp
WeightStores one row of the sparse matrix which makes up the multiclass perceptron.Classedu.stanford.nlp.parser.shiftreduceJavaNlp
WeightedRVFDatasetA weighted version of the RVF dataset.Classedu.stanford.nlp.classifyJavaNlp
WhitespaceTokenizerA WhitespaceTokenizer is a tokenizer that splits on and discards only whitespace characters.Classedu.stanford.nlp.processJavaNlp
WordA Word object acts as a Label by containing a String.Classedu.stanford.nlp.lingJavaNlp
WordFactoryA WordFactory acts as a factory for creating objects ofVersion:2000/12/20Author:Christopher ManningClassedu.stanford.nlp.lingJavaNlp
WordLemmaTagA WordLemmaTag corresponds to a pair of a tagged (e.Classedu.stanford.nlp.lingJavaNlp
WordLemmaTagFactory A WordLemmaTagFactory acts as a factory for creating objects of class WordLemmaTag.Classedu.stanford.nlp.lingJavaNlp
WordNetConnectionAllows us to verify that a wordnet connection is available without compile time errors if the package is not found.Interfaceedu.stanford.nlp.treesJavaNlp
WordSegmenterAn interface for segmenting strings into words (in unwordsegmented languages).Interfaceedu.stanford.nlp.processJavaNlp
WordSegmentingTokenizerA tokenizer that works by calling a WordSegmenter.Classedu.stanford.nlp.processJavaNlp
WordShapeClassifierProvides static methods which map any String to another String indicative of its "word shape" -- e.Classedu.stanford.nlp.processJavaNlp
WordStemmerStems the Words in a Tree using Morphology.Classedu.stanford.nlp.treesJavaNlp
WordsToSentencesAnnotatorThis class assumes that there is a List under the TokensAnnotation field, and runs itClassedu.stanford.nlp.pipelineJavaNlp
WordTagA WordTag corresponds to a tagged (e.Classedu.stanford.nlp.lingJavaNlp
WordTagFactoryA WordTagFactory acts as a factory for creating objects of class WordTag.Classedu.stanford.nlp.lingJavaNlp
WordTokenFactoryConstructs a Word from a String.Classedu.stanford.nlp.processJavaNlp
WordToSentenceProcessorTransforms a List of words into a List of Lists of words (that is, a List of sentences), by grouping the words.Classedu.stanford.nlp.processJavaNlp
WordToTaggedWordProcessorTransforms a Document of Words into a document all or partly of TaggedWords by breaking words on a tag divider character.Classedu.stanford.nlp.processJavaNlp
XMLBeginEndIteratorA class which iterates over Strings occurring between the begin and end of a selected tag or tags.Classedu.stanford.nlp.objectbankJavaNlp
XMLOutputterAn outputter to XML format.Classedu.stanford.nlp.pipelineJavaNlp
XMLUtilsProvides some utilities for dealing with XML files, both by properly parsing them and by using the methods of a desperate Perl hacker.Classedu.stanford.nlp.utilJavaNlp
AboutBoxThis plugin implements the Help/About ImageJ command by opening the about.Classij.pluginImageJ
AnalyzerThis plugin implements ImageJ's Analyze/Measure and Analyze/Set Measurements commands.Classij.plugin.filterImageJ
AnimatorThis plugin animates stacks.Classij.pluginImageJ
AppearanceOptionsThis plugin implements the Edit/Options/Appearance command.Classij.pluginImageJ
ArrowThis is an Roi subclass for creating and displaying arrows.Classij.guiImageJ
ArrowToolOptionsThis plugin implements the Edit/Options/Arrow Tool command.Classij.pluginImageJ
AutoThresholderAutothresholding methods (limited to 256 bin histograms) from the Auto_Threshold plugin (http://fiji.Classij.processImageJ
AVI_Reader ImageJ Plugin for reading an AVI file into an image stack (one slice per video frame)Classij.pluginImageJ
AVI_WriterThis plugin implements the File/Save As/AVI command.Classij.plugin.filterImageJ
BackgroundSubtracterrolling ball algorithm described in Stanley Sternberg's article, "Biomedical ImageProcessing", IEEE Computer, January 1983.Classij.plugin.filterImageJ
BatchConverterThis plugin implements the File/ /Convert command, which converts the images in a folder to a specified format.Classij.pluginImageJ
BatchMeasureThis plugin implements the File/Batch/Measure command, which measures all the images in a user-specified folder.Classij.pluginImageJ
BatchProcessorThis plugin implements the File/Batch/Macro and File/Batch/Virtual Stack commands.Classij.pluginImageJ
Benchmark results and additional benchmarks are available at "http://imagej.Classij.plugin.filterImageJ
Binary and Fill Holes commands in the Process/Binary submenu.Classij.plugin.filterImageJ
BinaryProcessorThis class processes binary images.Classij.processImageJ
BinnerThis plugin implements the Image/Transform/Bin command.Classij.pluginImageJ
BitBufferA class for reading arbitrary numbers of bits from a byte array.Classij.ioImageJ
BlitterImageJ bit blitting classes must implement this interface.Interfaceij.processImageJ
BMP_ReaderThis plugin reads BMP files.Classij.pluginImageJ
BMP_Writer http://www.Classij.pluginImageJ
BrowserLauncherThis plugin implements the File/Import/URL command and the commands in the Help menu that open web pages.Classij.pluginImageJ
ByteBlitterThis class does bit blitting of byte images.Classij.processImageJ
ByteProcessorThis is an 8-bit image and methods that operate on that image.Classij.processImageJ
ByteStatistics8-bit image statistics, including histogram.Classij.processImageJ
CalibrationCalibration objects contain an image's spatial and density calibration data.Classij.measureImageJ
CalibrationBarThis plugin implements the Analyze/Tools/Calibration Bar command.Classij.pluginImageJ
CanvasResizerThis plugin implements the Image/Adjust/Canvas Size command.Classij.pluginImageJ
ChannelArrangerThis plugin implements the Image/Colors/Arrange Channels command, which allows the user to change the order of channels.Classij.pluginImageJ
ChannelsDisplays the ImageJ Channels window.Classij.plugin.frameImageJ
ChannelSplitterThis plugin implements the Image/Color/Split Channels command.Classij.pluginImageJ
CircularRoiMakerThis class implements the Process/FFT/Make Circular Selection command.Classij.pluginImageJ
ClassCheckerChecks for duplicate class and JAR files in the plugins folders and deletes older duplicates.Classij.pluginImageJ
ClipboardCopies/pastes images to/from the system clipboard.Classij.pluginImageJ
ColorBlitterThis class does bit blitting of RGB images.Classij.processImageJ
ColorChooserDisplays a dialog that allows the user to select a color using three sliders.Classij.guiImageJ
ColorProcessorThis is an 32-bit RGB image and methods that operate on that image.Classij.processImageJ
ColorsThis plugin implements most of the Edit/Options/Colors command.Classij.pluginImageJ
ColorSpaceConverter Created Jan 15, 2004 Version 3 posted on ImageJ Mar 12, 2006 by Duane SchwartzwaldClassij.processImageJ
ColorStatisticsRGB image statistics, including histogram.Classij.processImageJ
ColorThresholderSelects pixels according to hsb or rgb components.Classij.plugin.frameImageJ
CommandListenerPlugins that implement this interface are notified when ImageJ is about to run a menu command.InterfaceijImageJ
CommandListerThis class is used by the Plugins/Shortcuts/List Shortcuts command to display a list keyboard shortcuts.Classij.pluginImageJ
CommandsRuns miscellaneous File and Window menu commands.Classij.pluginImageJ
CompilerCompiles and runs plugins using the javac compiler.Classij.pluginImageJ
CompositeConverterThis plugin implements the Image/Color/Make Composite command.Classij.pluginImageJ
ConcatenatorThis plugin, which concatenates two or more images or stacks, implements the Image/Stacks/Tools/Concatenate command.Classij.pluginImageJ
ContrastAdjusterThis plugin implements the Brightness/Contrast, Window/level and Color Balance commands, all in the Image/Adjust sub-menu.Classij.plugin.frameImageJ
ControlPanel This plugin displays a panel with ImageJ commands in a hierarchical tree structure.Classij.pluginImageJ
ConvolverThis plugin convolves images using user user defined kernels.Classij.plugin.filterImageJ
CurveFitterCurve fitting class based on the Simplex method in the Minimizer class Notes on fitting polynomial functions:Classij.measureImageJ
DialogListenerPlugIns or PlugInFilters that want to listen to changes in a GenericDialog without adding listeners for each dialog field should implementthis method.Interfaceij.guiImageJ
DICOMThis plugin decodes DICOM files.Classij.pluginImageJ
DirectoryChooserThis class displays a dialog box that allows the user can select a directory.Classij.ioImageJ
DistributionThis plugin implements the Analyze/Distribution command.Classij.pluginImageJ
DownsizeTableA table for easier downsizing by convolution with a kernel.Classij.processImageJ
DragAndDropThis class opens images, roi's, luts and text files dragged and dropped on the "ImageJ" window.Classij.pluginImageJ
DuplicatorThis plugin implements the Image/Duplicate command.Classij.pluginImageJ
EditorThis is a simple TextArea based editor for editing and compiling plugins.Classij.plugin.frameImageJ
EDMThis plugin implements the Euclidean Distance Map (EDM), Watershed, Ultimate Eroded Points and Voronoi commands in the Process/Binary submenu.Classij.plugin.filterImageJ
EllipseFitterThis class fits an ellipse to an ROI.Classij.processImageJ
EllipseRoiElliptical region of interest.Classij.guiImageJ
EventListenerThis plugin implements the Plugins/Utilities/Monitor Events command.Classij.pluginImageJ
ExecuterRuns ImageJ menu commands in a separate thread.ClassijImageJ
ExtendedPlugInFilterImageJ plugins that process an image may implement this interface.Interfaceij.plugin.filterImageJ
FFTThis class implements the FFT, Inverse FFT and Redisplay Power Spectrum commands in the Process/FFT submenu.Classij.pluginImageJ
FFTCustomFilterThis class implements the Process/FFT/Custom Filter command.Classij.plugin.filterImageJ
FFTFilterThis class implements the Process/FFT/Bandpass Filter command.Classij.plugin.filterImageJ
FFTMathThe class implements the Process/FFT/Math command.Classij.pluginImageJ
FHTThis class contains a Java implementation of the Fast HartleyTransform.Classij.processImageJ
FileInfoThis class consists of public fields that describe an image file.Classij.ioImageJ
FileInfoVirtualStackThis plugin opens a multi-page TIFF file as a virtual stack.Classij.pluginImageJ
FileOpenerOpens or reverts an image specified by a FileInfo object.Classij.ioImageJ
FileSaverSaves images in tiff, gif, jpeg, raw, zip and text format.Classij.ioImageJ
FillerThis plugin implements ImageJ's Fill, Clear, Clear Outside and Draw commands.Classij.plugin.filterImageJ
FiltersThis plugin implements the Invert, Smooth, Sharpen, Find Edges, and Add Noise commands.Classij.plugin.filterImageJ
FITS_ReaderOpens and displays FITS images.Classij.pluginImageJ
FITS_WriterThis plugin saves a 16 or 32 bit image in FITS format.Classij.pluginImageJ
FitterImageJ plugin that does curve fitting using the modified CurveFitter class.Classij.plugin.frameImageJ
FloatBlitterThis class does bit blitting of 32-bit floating-point images.Classij.processImageJ
FloatPolygonUsed by the Roi classes to return float coordinate arrays and to determine if a point is inside or outside of spline fitted selections.Classij.processImageJ
FloatProcessorThis is an 32-bit floating-point image and methods that operate on that image.Classij.processImageJ
FloatStatistics32-bit (float) image statistics, including histogram.Classij.processImageJ
FloodFillerThis class, which does flood filling, is used by the floodFill() macro function and by the particle analyzerClassij.processImageJ
FolderOpener opens a folder of images as a stack.Classij.pluginImageJ
FractalBoxCounterCalculate the so-called "capacity" fractal dimension.Classij.plugin.filterImageJ
FreehandRoiFreehand region of interest or freehand line of interestSee Also:Serialized FormClassij.guiImageJ
FunctionFinderThis class implements the text editor's Macros/Find Functions command.Classij.macroImageJ
FunctionsThis class implements the built-in macro functions.Classij.macroImageJ
GaussianBlurThis plug-in filter uses convolution with a Gaussian function for smoothing.Classij.plugin.filterImageJ
GelAnalyzerThis plugin generates gel profile plots that can be analyzed usingthe wand tool.Classij.pluginImageJ
GenericDialogThis class is a customizable modal dialog box.Classij.guiImageJ
GIF_ReaderThis plugin opens GIFs and Animated GIFs.Classij.pluginImageJ
GridThis class implements the Analyze/Tools/Grid command.Classij.pluginImageJ
GroupedZProjectorThis plugin implements the Image/Stacks/Tools/Grouped Z Project command.Classij.pluginImageJ
GUIThis class consists of static GUI utility methods.Classij.guiImageJ
HistogramThis plugin implements the Analyze/Histogram command.Classij.pluginImageJ
HistogramWindowThis class is an extended ImageWindow that displays histograms.Classij.guiImageJ
HTMLDialogThis is modal or non-modal dialog box that displays HTML formated text.Classij.guiImageJ
HyperStackConverter and "HyperStack to Stack" commands.Classij.pluginImageJ
HyperStackMakerThis plugin implements the File/New/Hyperstack command.Classij.pluginImageJ
IJThis class consists of static utility methods.ClassijImageJ
IJEventListenerPlugins that implement this interface are notified when the user changes the foreground color, changes the background color,InterfaceijImageJ
ImageCalculatorThis plugin implements the Process/Image Calculator command.Classij.pluginImageJ
ImageCanvasThis is a Canvas used to display images in a Window.Classij.guiImageJ
ImageConverterThis class converts an ImagePlus object to a different type.Classij.processImageJ
ImageJThis frame is the main ImageJ class.ClassijImageJ
ImageJ_UpdaterThis plugin implements the Help/Update ImageJ command.Classij.pluginImageJ
ImageJAppletRuns ImageJ as an applet and optionally opens up to nine images using URLs passed as a parameters.ClassijImageJ
ImageLayoutThis is a custom layout manager that supports resizing of zoomedimages.Classij.guiImageJ
ImageListenerPlugins that implement this interface are notified when an image is opened, closed or updated.InterfaceijImageJ
ImageMathThis plugin implements ImageJ's Process/Math submenu.Classij.plugin.filterImageJ
ImagePanelThis class is used by GenericDialog to add images to dialogs.Classij.guiImageJ
ImagePlusAn ImagePlus contain an ImageProcessor (2D image) or an ImageStack (3D, 4D or 5D image).ClassijImageJ
ImageProcessorThis abstract class is the superclass for classes that processthe four data types (byte, short, float and RGB) supported by ImageJ.Classij.processImageJ
ImageReaderReads raw 8-bit, 16-bit or 32-bit (float or RGB) images from a stream or URL.Classij.ioImageJ
ImageRoiAn ImageRoi is an Roi that overlays an image.Classij.guiImageJ
ImageStackThis class represents an expandable array of images.ClassijImageJ
ImageStatisticsStatistics, including the histogram, of an image or selection.Classij.processImageJ
ImageWindowA frame for displaying images.Classij.guiImageJ
ImageWriterWrites a raw image described by a FileInfo object to an OutputStream.Classij.ioImageJ
ImportDialogThis is a dialog box used to imports raw 8, 16, 24 and 32-bit images.Classij.ioImageJ
InfoThis plugin implements the Image/Show Info command.Classij.plugin.filterImageJ
InterpreterThis is the recursive descent parser/interpreter for the ImageJ macro language.Classij.macroImageJ
Java2This class contains static methods that use the Java 2 API.Classij.utilImageJ
JavaPropertiesDisplays the Java system properties in a text window.Classij.pluginImageJ
JavaScriptEvaluator on systems running Java 1.Classij.pluginImageJ
JpegWriterThe File/Save As/Jpeg command (FileSaver.Classij.pluginImageJ
LineThis class represents a straight line selection.Classij.guiImageJ
LineWidthAdjusterAdjusts the width of line selections.Classij.plugin.frameImageJ
ListVirtualStackThis plugin opens images specified by list of file paths as a virtual stack.Classij.pluginImageJ
LogStreamThis class provides the functionality to divert output sent to the System.Classij.ioImageJ
LookUpTableThis class represents a color look-up table.ClassijImageJ
LUTThis is an indexed color model that allows an lower and upper bound to be specified.Classij.processImageJ
LutApplierThis plugin implements the Image/Lookup Tables/Apply LUT command.Classij.plugin.filterImageJ
LutLoaderOpens NIH Image look-up tables (LUTs), 768 byte binary LUTs (256 reds, 256 greens and 256 blues), LUTs in text format, Classij.pluginImageJ
LutViewerDisplays the active image's look-up table.Classij.plugin.filterImageJ
MacroThe class contains static methods that perform macro operations.ClassijImageJ
Macro_RunnerThis class runs macros and scripts installed in the Plugins menu as well as macros and scripts opened using the Plugins/Macros/Run command.Classij.pluginImageJ
MacroInstallerThis plugin implements the Plugins/Macros/Install Macros command.Classij.pluginImageJ
MacroRunnerThis class runs macros in a separate thread.Classij.macroImageJ
MaximumFinderThis ImageJ plug-in filter finds the maxima (or minima) of an image.Classij.plugin.filterImageJ
MeasurementsWriterWrites measurements to a csv or tab-delimited text file.Classij.pluginImageJ
MedianCutConverts an RGB image to 8-bit index color using Heckbert's median-cut color quantization algorithm.Classij.processImageJ
MemoryThis plugin implements the Edit/Options/Memory command.Classij.pluginImageJ
MemoryMonitorThis plugin continuously plots ImageJ's memory utilization.Classij.plugin.frameImageJ
MenusThis class installs and updates ImageJ's menus.ClassijImageJ
MessageDialogA modal dialog box that displays information.Classij.guiImageJ
MinimizerMinimizer based on Nelder-Mead simplex method (also known as polytope method), including the 'outside contraction' as described in:Classij.measureImageJ
MultiLineLabelCustom component for displaying multiple lines.Classij.guiImageJ
NewImageNew image dialog box plus several static utility methods for creating images.Classij.guiImageJ
NewPluginThis class creates a new macro or the Java source for a new plugin.Classij.pluginImageJ
NonBlockingGenericDialogThis is an extension of GenericDialog that is non-model.Classij.guiImageJ
OpenDialogThis class displays a dialog window from which the user can select an input file.Classij.ioImageJ
OpenerOpens tiff (and tiff stacks), dicom, fits, pgm, jpeg, bmp or gif images, and look-up tables, using a file open dialog or a path.Classij.ioImageJ
OptionsThis plugin implements most of the commands in the Edit/Options sub-menu.Classij.pluginImageJ
Orthogonal_ViewsThis plugin projects dynamically orthogonal XZ and YZ views of a stack.Classij.pluginImageJ
OvalRoiOval region of interestSee Also:Serialized FormClassij.guiImageJ
OverlayAn Overlay is a list of ROIs that can be drawn non-destructively on an Image.Classij.guiImageJ
OverlayCommandsThis plugin implements the commands in the Image/Overlay menu.Classij.pluginImageJ
OverlayLabelsThis plugin implements the Image/Overlay/Labels command.Classij.pluginImageJ
ParticleAnalyzer for each line do for each pixel in this line doClassij.plugin.filterImageJ
PGM_ReaderThis plugin opens PxM format images.Classij.pluginImageJ
PixelInspectionToolThis plugin continuously displays the pixel values of the cursor and its surroundings.Classij.plugin.toolImageJ
PlotThis class creates an image that line graphs, scatter plots and plots of vector fields (arrows) can be drawn on and displayed.Classij.guiImageJ
PlotCanvasThis subclass of ImageCanvas has special provisions for plots: - Zooming: sets the plot rangeClassij.guiImageJ
PlotMakerPlugins that generate "Live" profile plots (Profiler and ZAxisProfiler) displayed in PlotWindows implement this interface.Interfaceij.guiImageJ
PlotWindowThis class implements the Analyze/Plot Profile command.Classij.guiImageJ
PlugInPlugins that acquire images or display windows should implement this interface.Interfaceij.pluginImageJ
PluginClassLoaderImageJ uses this class loader to load plugins and resources from the plugins directory and immediate subdirectories.Classij.ioImageJ
PlugInDialogThis is a non-modal dialog that plugins can extend.Classij.plugin.frameImageJ
PlugInFilterImageJ plugins that process an image should implement this interface.Interfaceij.plugin.filterImageJ
PlugInFrameThis is a closeable window that plugins can extend.Classij.plugin.frameImageJ
PluginInstallerInstalls plugins dragged and dropped on the "ImageJ" window, or plugins, macros or scripts opened using the Plugins/Install command.Classij.pluginImageJ
PlugInInterpreterPlugins that run scripts (e.Classij.pluginImageJ
PNG_WriterSaves in PNG format using the ImageIO classes.Classij.pluginImageJ
PointRoiThis class represents a collection of points.Classij.guiImageJ
PointToolOptionsThis plugin implements the Edit/Options/Point Tool command.Classij.pluginImageJ
PolygonFillerThis class fills polygons using the scan-line filling algorithm described at "http://www.Classij.processImageJ
PolygonRoiThis class represents a polygon region of interest or polyline of interest.Classij.guiImageJ
PrefsThis class contains the ImageJ preferences, which are loaded from the "IJ_Props.ClassijImageJ
PrinterThis plugin implements the File/Page Setup and File/Print commands.Classij.plugin.filterImageJ
ProfilePlotCreates a density profile plot of a rectangular selection or line selection.Classij.guiImageJ
ProgramAn object of this type is a tokenized macro file and the associated symbol table.Classij.macroImageJ
ProgressBarThis is the progress bar that is displayed in the lower right hand corner of the ImageJ window.Classij.guiImageJ
ProjectorThis plugin creates a sequence of projections of a rotating volume (stack of slices) onto a plane usingnearest-point (surface), brightest-point, or mean-value projection or a weighted combination of nearest-Classij.pluginImageJ
ProxySettingsThis plugin implements the Plugins/Utilities/Proxy Settings command.Classij.pluginImageJ
RandomAccessStreamThis class uses a memory cache to allow seeking within an InputStream.Classij.ioImageJ
RankFiltersThis plugin implements the Mean, Minimum, Maximum, Variance, Median, Open Maxima, Close Maxima, Remove Outliers, Remove NaNs and Despeckle commands.Classij.plugin.filterImageJ
RawThis plugin implements the File/Import/Raw command.Classij.pluginImageJ
RecentOpenerOpens, in a separate thread, files selected from the File/Open Recent submenu.ClassijImageJ
RecorderThis is ImageJ's macro recorder.Classij.plugin.frameImageJ
RectToolOptionsThis plugin implements the rounded rectangle tool dialog box.Classij.pluginImageJ
ResizerThis plugin implements the Edit/Crop and Image/Adjust/Size commands.Classij.pluginImageJ
ResultsSorterThis plugin implements the Results Table's Sort command.Classij.pluginImageJ
ResultsTableThis is a table for storing measurement results and strings as columns of values.Classij.measureImageJ
RGBStackConverterConverts a 2 or 3 slice stack, or a hyperstack, to RGB.Classij.pluginImageJ
RGBStackMergeThis plugin implements the Image/Color/Merge Channels command.Classij.pluginImageJ
RGBStackSplitterDeprecated; replaced by ij.Classij.plugin.filterImageJ
RoiA rectangular region of interest and superclass for the other ROI classes.Classij.guiImageJ
RoiDecoderDecodes an ImageJ, NIH Image or Scion Image ROI file.Classij.ioImageJ
RoiEncoderSaves an ROI to a file or stream.Classij.ioImageJ
RoiEnlargerThis plugin, which enlarges or shrinks selections, implements the Edit/Selection/Enlarge command.Classij.pluginImageJ
RoiInterpolatorThis class interpolates between ROIs in the ROI Manager.Classij.pluginImageJ
RoiListenerPlugins that implement this interface are notified when an ROI is created, modified or deleted.Interfaceij.guiImageJ
RoiManagerThis plugin implements the Analyze/Tools/ROI Manager command.Classij.plugin.frameImageJ
RoiPropertiesDisplays a dialog that allows the user to specify ROI properties such as color and line width.Classij.guiImageJ
RoiReaderOpens ImageJ, NIH Image and Scion Image for windows ROI outlines.Classij.pluginImageJ
RoiRotatorThis plugin implements the Edit/Selection/Rotate command.Classij.pluginImageJ
RoiScalerThis plugin implements the Edit/Selection/Scale command.Classij.pluginImageJ
RoiWriterSaves the current ROI outline to a file.Classij.plugin.filterImageJ
RotatorThis plugin implements the Image/Rotate/Arbitrarily command.Classij.plugin.filterImageJ
SaveChangesDialogA modal dialog box with a one line message and "Don't Save", "Cancel" and "Save" buttons.Classij.guiImageJ
SaveDialogThis class displays a dialog window from which the user can save a file.Classij.ioImageJ
ScaleBarThis plugin implements the Analyze/Tools/Draw Scale Bar command.Classij.pluginImageJ
ScalerThis plugin implements the Image/Scale command.Classij.pluginImageJ
ScreenGrabberThis plugin implements the Plugins/Utilities/Capture Screen and Plugins/Utilities/Capture Image commands.Classij.pluginImageJ
ScrollbarWithLabelThis class, based on Joachim Walter's Image5D package, adds "c", "z" labels and play-pause icons (T) to the stack and hyperstacks dimension sliders.Classij.guiImageJ
SelectionThis plugin implements the commands in the Edit/Section submenu.Classij.pluginImageJ
ShapeRoiA subclass of ij.Classij.guiImageJ
ShortBlitterThis class does bit blitting of 16-bit images.Classij.processImageJ
ShortProcessorShortProcessors contain a 16-bit unsigned image and methods that operate on that image.Classij.processImageJ
ShortStatistics16-bit image statistics, including histogram.Classij.processImageJ
SimpleCommandsThis plugin implements the Plugins/Utilities/Unlock, Image/Rename and Plugins/Utilities/Search commands.Classij.pluginImageJ
Slicer for FREELINE or POLYLINE ROI, spatial calibration is ignored: the image is sampled at constant _pixel_ increments (distance 1), so Classij.pluginImageJ
SpecifyROIThis plugin implements the Edit/Selection/Specify command.Classij.pluginImageJ
SplineFitterThis class fits a spline function to a set of points.Classij.measureImageJ
Stack_StatisticsThis plugin implements the Image/Stacks/Statistics command.Classij.pluginImageJ
StackCombinerThis plugin implements the Image/Stacks/Combine command.Classij.pluginImageJ
StackConverterThis class does stack type conversions.Classij.processImageJ
StackInserterThis plugin, which implements the Image/Stacks/Tools/Insert command, inserts an image or stack into another image or stack.Classij.pluginImageJ
StackLabelerThis plugin implements the Image/Stacks/Label command.Classij.plugin.filterImageJ
StackMakerThe plugin implements the Image/Stacks/Tools/Montage to Stack command.Classij.pluginImageJ
StackProcessorThis class processes stacks.Classij.processImageJ
StackReducerThis plugin implements the Image/Stacks/Tools/Reduce command.Classij.pluginImageJ
StackReverserThis plugin implements the Image/Transform/Flip Z and Image/Stacks/Tools/Reverse commands.Classij.pluginImageJ
StackStatisticsStatistics, including the histogram, of a stack.Classij.processImageJ
StackWindowThis class is an extended ImageWindow that displays stacks and hyperstacks.Classij.guiImageJ
StackWriterThis plugin, which saves the images in a stack as separate files, implements the File/Save As/Image Sequence command.Classij.pluginImageJ
StartupThis plugin implements the Edit/Options/Startup command.Classij.pluginImageJ
StraightenerThis plugin implements the Edit/Selection/Straighten command.Classij.pluginImageJ
StringSorterA simple QuickSort for String arrays.Classij.utilImageJ
SubHyperstackMakerThis plugin is used by the Image/Stacks/Tools/Make Substack command to create substacks of hyperstacks.Classij.pluginImageJ
SubstackMakerThis plugin implements the Image/Stacks/Tools/Make Substack command.Classij.pluginImageJ
SymbolObjects of this class are used as entries in the macro language symbol table.Classij.macroImageJ
SyncWindowsThis class "synchronizes" mouse input in multiple windows.Classij.plugin.frameImageJ
TextThis plugin implements the Edit/Options/Fonts command and the dialog displayed when you double click on the text tool.Classij.pluginImageJ
TextEncoderSaves an image described by an ImageProcessor object as a tab-delimited text file.Classij.ioImageJ
TextFileReaderThis plugin displays the contents of a text file in a window.Classij.pluginImageJ
TextPanelThis is an unlimited size text panel with tab-delimited,labeled and resizable columns.Classij.textImageJ
TextReaderThis plugin opens a tab or comma delimeted text file as an image.Classij.pluginImageJ
TextRoiThis class is a rectangular ROI containing text.Classij.guiImageJ
TextWindowUses a TextPanel to displays text in a window.Classij.textImageJ
TextWriterThis plugin implements the File/Save As/Text command, which saves the contents of Editor windows and TextWindows (e.Classij.pluginImageJ
ThreadListerDisplays thread information in a text window.Classij.pluginImageJ
ThresholdAdjusterAdjusts the lower and upper threshold levels of the active image.Classij.plugin.frameImageJ
ThresholderThis plugin implements the Process/Binary/Make Binary and Convert to Mask commands.Classij.pluginImageJ
TiffDecoderDecodes single and multi-image TIFF files.Classij.ioImageJ
TiffEncoderSaves an image described by a FileInfo object as an uncompressed, big-endian TIFF file.Classij.ioImageJ
TimerImageJ plugin for measuring the speed of various Java operations.Classij.pluginImageJ
TokenizerThis class converts an imageJ macro file file into a token stream.Classij.macroImageJ
ToolsThis class contains static utility methods.Classij.utilImageJ
TranslatorThis plugin implements the Image/Translate command.Classij.plugin.filterImageJ
TrimmedButtonThis is an extended Button class used to reduce the width of the HUGE buttons on Mac OS X.Classij.guiImageJ
TypeConverterThis class converts an ImageProcessor to another data type.Classij.processImageJ
UndoThis class consists of static methods and fields that implement ImageJ's Undo command.ClassijImageJ
UnsharpMaskThis plugin-filter implements ImageJ's Unsharp Mask command.Classij.plugin.filterImageJ
URLOpenerOpens TIFFs, ZIP compressed TIFFs, DICOMs, GIFs and JPEGs using a URL.Classij.pluginImageJ
UserFunctionA plugin should implement this interface for minimizing a single-valued function or fitting a curve with a custom fit function.Interfaceij.measureImageJ
VirtualStackThis class represents an array of disk-resident images.ClassijImageJ
WaitForUserDialogThis is a non-modal dialog box used to ask the user to perform some task while a macro or plugin is running.Classij.guiImageJ
WandThis class implements ImageJ's wand (tracing) tool.Classij.guiImageJ
WandToolOptionsThis plugin implements the Edit/Options/Wand Tool command.Classij.pluginImageJ
WildcardMatchThis class allows for simple wildcard pattern matching.Classij.utilImageJ
WindowManagerThis class consists of static methods used to manage ImageJ's windows.ClassijImageJ
WindowOrganizerThis class implements the Window menu's "Show All", "Main Window", "Cascade" and "Tile" commands.Classij.pluginImageJ
WriterThis plugin saves an image in tiff, gif, jpeg, bmp, png, text or raw format.Classij.plugin.filterImageJ
XY_ReaderThis plugin implements the File/Import/XY Coordinates command.Classij.pluginImageJ
XYCoordinatesWrites the XY coordinates and pixel values of all non-background pixels to a tab-delimited text file.Classij.pluginImageJ
XYWriterSaves the XY coordinates of the current ROI boundary.Classij.plugin.filterImageJ
YesNoCancelDialogA modal dialog box with a one line message and "Yes", "No" and "Cancel" buttons.Classij.guiImageJ
ZoomThis plugin implements the commands in the Image/Zoom submenu.Classij.pluginImageJ
ZProjectorThis plugin performs a z-projection of the input stack.Classij.pluginImageJ
AddressBookDoCoMoResultParser Supported keys: N, SOUND, TEL, EMAIL, NOTE, ADR, BDAY, URL, plus ORG Unsupported keys: TEL-AV,
AlignmentPatternEncapsulates an alignment pattern, which are the smaller square patterns found in all but the simplest QR
AztecCodeAztec 2D code representationAuthor:Rustam
AztecReaderThis implementation can detect and decode Aztec codes in an
BarcodeFormatEnumerates barcode formats known to this
BinarizerThis class hierarchy provides a set of methods to convert luminance data to 1 bit
BinaryBitmapThis class is the core bitmap class used by ZXing to represent 1 bit
BitArrayA simple, fast array of bits, represented compactly by an array of ints
BitMatrixRepresents a 2D matrix of
BitSourceThis provides an easy abstraction to read bits at a time from a sequence of bytes, where the number of bits read is not often a multiple of
BizcardResultParser largely reverse-engineered from examples observed in the wild -- still looking for a definitive
BufferedImageLuminanceSourceThis LuminanceSource implementation is meant for J2SE clients and our blackbox unit
ByQuadrantReaderThis class attempts to decode a barcode from an image, not by scanning the whole image, but by scanning subsets of the
ByteMatrixJAVAPORT: The original code was a 2D array of ints, but since it only ever gets assigned -1, 0, and 1, I'm going to use less memory and go with
CalendarEventGeneratorA Generator for calendar
CameraConfigurationUtilsUtility methods for configuring the Android
CharacterSetECIenum CharacterSetECIEncapsulates a Character Set ECI, according to "Extended Channel Interpretations"
ChartServletA reimplementation of the Google Chart Server's QR code encoder, which is now
ChecksumExceptionThrown when a barcode was successfully detected and decoded, but was not returned because its checksum feature
CodaBarReaderDecodes Codabar
CodaBarWriterThis class renders CodaBar as boolean[]
Code128ReaderDecodes Code 128
Code128WriterThis object renders a CODE128 code as a
Code39ReaderDecodes Code 39
Code39WriterThis object renders a CODE39 code as a
Code93ReaderDecodes Code 93
CommandLineEncoderCommand line utility for encoding
CommandLineRunnerThis simple command line utility decodes files, directories of files, or URIs which are passed as
ContactInfoGeneratorA Generator for contact informations, output is in MeCard
DataMatrixReaderThis implementation can detect and decode Data Matrix codes in an
DataMatrixWriterThis object renders a Data Matrix code as a BitMatrix 2D array of greyscale
DecodeHintTypeEncapsulates a type of hint that a caller may pass to a barcode reader to help it more quickly or accurately decode
DecoderThe main class which implements Aztec Code decoding -- as opposed to locating and extracting the Aztec Code from an
DecoderThe main class which implements Data Matrix Code decoding -- as opposed to locating and extracting the Data Matrix Code from an
DecoderThe main class which implements MaxiCode decoding -- as opposed to locating and extracting the MaxiCode from an
DecoderThe main class which implements QR Code decoding -- as opposed to locating and extracting the QR Code from an
DecoderResultEncapsulates the result of decoding a matrix of
DecodeServletHttpServlet which decodes images containing
DefaultPlacementSymbol Character Placement
DetectorEncapsulates logic that can detect an Aztec Code in an image, even if the Aztec Code is rotated or skewed, or partially
DetectorEncapsulates logic that can detect a Data Matrix Code in an image, even if the Data Matrix Code is rotated or skewed, or partially
DetectorEncapsulates logic that can detect a PDF417 Code in an image, even if the PDF417 Code is rotated or skewed, or partially
DetectorEncapsulates logic that can detect a QR Code in an image, even if the QR Code is rotated or skewed, or partially
DetectorResultEncapsulates the result of detecting a barcode in an
DimensionSimply encapsulates a width and
DimensionsData object to specify the minimum and maximum number of rows and columns for a PDF417
DoSFilterA simplistic Filter that rejects requests from hosts that are sending too many requests in too short a
EAN13WriterThis object renders an EAN13 code as a
EAN8WriterThis object renders an EAN8 code as a
EmailAddressResultParserRepresents a result that encodes an e-mail address, either as a plain address like "
EmailGeneratorGenerator for email
EncodeHintTypeThese are a set of hints that you may pass to Writers to specify their
EncoderGenerates Aztec 2D
ErrorCorrectionError Correction Code for
ErrorCorrectionPDF417 error correction
ErrorCorrectionLevelenum ErrorCorrectionLevelSee ISO 18004:2006,
ExpandedProductResultParserParses strings of digits that represent a RSS Extended
FinderPatternEncapsulates a finder pattern, which are the three square patterns found in the corners of QR
FinderPatternFinderThis class attempts to find finder patterns in a QR
FinderPatternInfoEncapsulates information about finder patterns in an image, including the location of the three finder patterns, and their estimated module
FormatExceptionThrown when a barcode was successfully detected, but some aspect of the content did not conform to the barcode's format
GeneratorSourceBase interface for any
GenericGFThis class contains utility methods for performing mathematical operations over the Galois
GenericMultipleBarcodeReaderAttempts to locate multiple barcodes in an image by repeatedly decoding portion of the
GeoLocationGeneratorA generator for geo
GeoResultParserParses a "geo:" URI result, which specifies a location on the surface of the Earth as well as an optional altitude above the
GlobalHistogramBinarizerThis Binarizer implementation uses the old ZXing global histogram
GridSampler image, sample the right points in the image to reconstruct the QR code, accounting for perspective
GUIRunnerSimple GUI frontend to the
HighLevelEncoderThis produces nearly optimal encodings of text into the first-level of encoding used by Aztec
HybridBinarizerThis class implements a local thresholding algorithm, which while slower than the GlobalHistogramBinarizer, is fairly efficient for what it
ImageReaderEncapsulates reading URIs as
IntentIntegratorA utility class which helps ease integration with Barcode Scanner via
IntentResultEncapsulates the result of a barcode scan invoked through
InvertedLuminanceSourceA wrapper implementation of LuminanceSource which inverts the luminances it returns -- black becomes white and vice versa, and each value becomes (255-value)
ISBNResultParserParses strings of digits that represent a
ITFReader This Reader will scan ITF barcodes of certain lengths
ITFWriterThis object renders a ITF code as a
LuminanceSourceThe purpose of this class hierarchy is to abstract different bitmap implementations across platforms into a standard interface for requesting greyscale luminance
MatrixToImageConfigEncapsulates custom configuration used in methods of
MatrixToImageWriterWrites a BitMatrix to BufferedImage, file or
MaxiCodeReaderThis implementation can detect and decode a MaxiCode in an
ModeSee ISO 18004:2006,
ModulusGFA field based on powers of a generator integer, modulo some
MonochromeRectangleDetectorA somewhat generic detector that looks for a barcode-like rectangular region within an
MultiDetectorEncapsulates logic that can detect one or more QR Codes in an image, even if the QR Code is rotated or skewed, or partially
MultiFormatReaderMultiFormatReader is a convenience class and the main entry point into the library for most
MultiFormatUPCEANReaderA reader that can read all available UPC/EAN
MultiFormatWriterThis is a factory class which finds the appropriate Writer subclass for the BarcodeFormat requested and encodes the barcode with the supplied
NotFoundExceptionThrown when a barcode was not found in the
OneDimensionalCodeWriterEncapsulates functionality and implementation that is common to one-dimensional
OneDReaderEncapsulates functionality and implementation that is common to all families of one-dimensional
OutputUtilsUtility functions for
ParsedResultAbstract class representing the result of decoding a barcode, as more than a String -- as some type of structured
ParsedResultTypeenum ParsedResultTypeRepresents the type of data encoded by a barcode -- from plain text, to
PDF417Top-level class for the logic part of the PDF417
PDF417ReaderThis implementation can detect and decode PDF417 codes in an
PerspectiveTransformThis class implements a perspective transform in two
PhoneNumberGeneratorA generator for a phone
PlanarYUVLuminanceSourceThis object extends LuminanceSource around an array of YUV data returned from the camera driver, with the option to crop to a rectangle within the full
ProductResultParserParses strings of digits that represent a UPC
QRCodeDecoderMetaDataMeta-data container for QR Code
QRCodeMultiReaderThis implementation can detect and decode multiple QR Codes in an
QRCodeReaderThis implementation can detect and decode QR Codes in an
QRCodeWriterThis object renders a QR Code as a BitMatrix 2D array of greyscale
Reader the String it
ReaderExceptionThe general exception class throw when something goes wrong during decoding of a
ReedSolomonDecoder The algorithm will not be explained here, but the following references were helpful in creating this
ReedSolomonExceptionThrown when an exception occurs during Reed-Solomon decoding, such as when there are too many errors to
ResultEncapsulates the result of decoding a barcode within an
ResultMetadataTypeenum ResultMetadataTypeRepresents some type of metadata about the result of the decoding that the
ResultParserAbstract class representing the result of decoding a barcode, as more than a String -- as some type of structured
ResultPointEncapsulates a point of interest in an image containing a
ResultPointCallbackCallback which is invoked when a possible result point (significant point in the barcode image such as a corner) is
RGBLuminanceSourceThis class is used to help decode images from files which arrive as RGB data from an ARGB pixel
RSS14ReaderDecodes RSS-14, including truncated and stacked
RSSUtilsAdapted from listings in ISO/IEC 24724 Appendix B and Appendix
SmsAddressGeneratorA generator for a sms
SMSMMSResultParserParses an "sms:" URI result, which specifies a number to
SMSTOMMSTOResultParserParses an "smsto:" URI result, whose format is not standardized but appears to be like: smsto:number(:body)
SMTPResultParserParses an "smtp:" URI result, whose format is not standardized but appears to be like: smtp[:subject[:body]]
StringsResourceTranslatorA utility which auto-translates English strings in Android string resources using Pass the Android client res/ directory as first argument, and optionally message
StringUtilsCommon string-related
SymbolInfoSymbol info table for
SymbolShapeHintenum SymbolShapeHintEnumeration for DataMatrix symbol shape
TelResultParserParses a "tel:" URI result, which specifies a phone
TextGeneratorA generator for any text
UPCAWriterThis object renders a UPC-A code as a
UPCEANReaderEncapsulates functionality and implementation that is common to UPC and EAN families of one-dimensional
UPCEANWriterEncapsulates functionality and implementation that is common to UPC and EAN families of one-dimensional
URIResultParserTries to parse results that are a URI of some
UrlGeneratorA generator for URL
URLTOResultParserParses the "URLTO" result format, which is of the form "URLTO:[title]:[url]"
VCardResultParserParses contact information formatted according to the VCard (
VersionThe Version object encapsulates attributes about a particular size Data Matrix
VEventResultParserPartially implements the iCalendar format's "VEVENT" format for specifying a calendar
VINResultParserDetects a result that is likely a vehicle identification
WhiteRectangleDetector Detects a candidate barcode-like rectangular region within an
WifiGeneratorA Generator for Wifi
WifiResultParserParses a WIFI configuration
WriterThe base class for all objects which encode/generate a barcode
WriterExceptionA base class which covers the range of exceptions which may occur when encoding a barcode using the Writer
EventClassprocessing.eventGoogle Processing
FrameBufferEncapsulates a Frame Buffer Object for offscreen rendering.Classprocessing.openglGoogle Processing
KeyEventClassprocessing.eventGoogle Processing
LinePathThe LinePath class allows to represent polygonal paths, potentially composed by several disjoint polygonal segments.Classprocessing.openglGoogle Processing
LineStrokerClassprocessing.openglGoogle Processing
MouseEventClassprocessing.eventGoogle Processing
PAppletBase class for all sketches that use processing.Classprocessing.coreGoogle Processing
PConstantsNumbers shared throughout processing.Interfaceprocessing.coreGoogle Processing
PFontGrayscale bitmap font class used by Processing.Classprocessing.coreGoogle Processing
PGLProcessing-OpenGL abstraction layer.Classprocessing.openglGoogle Processing
PGraphics( begin auto-generated from PGraphics.Classprocessing.coreGoogle Processing
PGraphics2DClassprocessing.openglGoogle Processing
PGraphics3DClassprocessing.openglGoogle Processing
PGraphicsJava2DSubclass for PGraphics that implements the graphics API using Java2D.Classprocessing.coreGoogle Processing
PGraphicsOpenGLClassprocessing.openglGoogle Processing
PImage( begin auto-generated from PImage.Classprocessing.coreGoogle Processing
PMatrixInterfaceprocessing.coreGoogle Processing
PMatrix2D3x2 affine matrix implementation.Classprocessing.coreGoogle Processing
PMatrix3D4x4 matrix implementation.Classprocessing.coreGoogle Processing
PShaderThis class encapsulates a GLSL shader program, including a vertex and a fragment shader.Classprocessing.openglGoogle Processing
PShape( begin auto-generated from PShape.Classprocessing.coreGoogle Processing
PShapeOBJOBJ loading implemented using code from Saito's OBJLoader library: http://code.Classprocessing.coreGoogle Processing
PShapeOpenGLThis class holds a 3D model composed of vertices, normals, colors (per vertex) and texture coordinates (also per vertex).Classprocessing.openglGoogle Processing
PShapeSVGSVG stands for Scalable Vector Graphics, a portable graphics format.Classprocessing.coreGoogle Processing
PStyleClassprocessing.coreGoogle Processing
PVector( begin auto-generated from PVector.Classprocessing.coreGoogle Processing
TableGeneric class for handling tabular data, typically from a CSV, TSV, or other sort of spreadsheet file.Classprocessing.dataGoogle Processing
TableRowInterfaceprocessing.dataGoogle Processing
TextureThis class wraps an OpenGL texture.Classprocessing.openglGoogle Processing
TouchEventClassprocessing.eventGoogle Processing
XMLThis is the base class used for the Processing XML library, representing a single node of an XML tree.Classprocessing.dataGoogle Processing
FloatDictA simple table class to use a String as a lookup for an float value.Classprocessing.dataProcessing
FloatListHelper class for a list of floats.Classprocessing.dataProcessing
FrameBufferEncapsulates a Frame Buffer Object for offscreen rendering.Classprocessing.openglProcessing
IntDictA simple class to use a String as a lookup for an int value.Classprocessing.dataProcessing
IntListHelper class for a list of ints.Classprocessing.dataProcessing
JSONArrayA JSONArray is an ordered sequence of values.Classprocessing.dataProcessing
JSONObjectA JSONObject is an unordered collection of name/value pairs.Classprocessing.dataProcessing
LinePathThe LinePath class allows to represent polygonal paths, potentially composed by several disjoint polygonal segments.Classprocessing.openglProcessing
PAppletBase class for all sketches that use processing.Classprocessing.coreProcessing
PConstantsNumbers shared throughout processing.Interfaceprocessing.coreProcessing
PFontGrayscale bitmap font class used by Processing.Classprocessing.coreProcessing
PGLProcessing-OpenGL abstraction layer.Classprocessing.openglProcessing
PGraphics( begin auto-generated from PGraphics.Classprocessing.coreProcessing
PGraphicsJava2DSubclass for PGraphics that implements the graphics API using Java2D.Classprocessing.awtProcessing
PImage( begin auto-generated from PImage.Classprocessing.coreProcessing
PMatrix2D3x2 affine matrix implementation.Classprocessing.coreProcessing
PMatrix3D4x4 matrix implementation.Classprocessing.coreProcessing
PShaderThis class encapsulates a GLSL shader program, including a vertex and a fragment shader.Classprocessing.openglProcessing
PShape( begin auto-generated from PShape.Classprocessing.coreProcessing
PShapeJava2D At the moment, this is gradients and java.Classprocessing.awtProcessing
PShapeOBJThis class is not part of the Processing API and should not be used directly.Classprocessing.coreProcessing
PShapeOpenGLThis class holds a 3D model composed of vertices, normals, colors (per vertex) and texture coordinates (also per vertex).Classprocessing.openglProcessing
PShapeSVGThis class is not part of the Processing API and should not be used directly.Classprocessing.coreProcessing
PSurfaceNoneSurface that's not really visible.Classprocessing.coreProcessing
PVector( begin auto-generated from PVector.Classprocessing.coreProcessing
SortInternal sorter used by several data classes.Classprocessing.dataProcessing
StringDictA simple table class to use a String as a lookup for another String value.Classprocessing.dataProcessing
StringListHelper class for a list of Strings.Classprocessing.dataProcessing
TableGeneric class for handling tabular data, typically from a CSV, TSV, or other sort of spreadsheet file.Classprocessing.dataProcessing
TextureThis class wraps an OpenGL texture.Classprocessing.openglProcessing
ThinkDifferentDeal with issues related to thinking differently.Classprocessing.coreProcessing
XMLThis is the base class used for the Processing XML library, representing a single node of an XML tree.Classprocessing.dataProcessing