java.lang.Object
- org.opencv.ml.TrainData

```
public class TrainData
extends java.lang.Object
```
Class encapsulating training data. Please note that the class only specifies the interface of training data, but not implementation. All the statistical model classes in _ml_ module accepts Ptr<TrainData> as parameter. In other words, you can create your own class derived from TrainData and pass smart pointer to the instance of this class into StatModel::train. SEE: REF: ml_intro_data

Field Summary

Fields
Modifier and Type Field Description

protected long nativeObj

Constructor Summary

Constructors
Modifier Constructor Description

protected TrainData(long addr)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`static TrainData`	`__fromPtr__(long addr)`
`static TrainData`	`create(Mat samples, int layout, Mat responses)`	Creates training data from in-memory arrays.
`static TrainData`	`create(Mat samples, int layout, Mat responses, Mat varIdx)`	Creates training data from in-memory arrays.
`static TrainData`	`create(Mat samples, int layout, Mat responses, Mat varIdx, Mat sampleIdx)`	Creates training data from in-memory arrays.
`static TrainData`	`create(Mat samples, int layout, Mat responses, Mat varIdx, Mat sampleIdx, Mat sampleWeights)`	Creates training data from in-memory arrays.
`static TrainData`	`create(Mat samples, int layout, Mat responses, Mat varIdx, Mat sampleIdx, Mat sampleWeights, Mat varType)`	Creates training data from in-memory arrays.
`protected void`	`finalize()`
`int`	`getCatCount(int vi)`
`Mat`	`getCatMap()`
`Mat`	`getCatOfs()`
`Mat`	`getClassLabels()`	Returns the vector of class labels The function returns vector of unique labels occurred in the responses.
`Mat`	`getDefaultSubstValues()`
`int`	`getLayout()`
`Mat`	`getMissing()`
`int`	`getNAllVars()`
`void`	`getNames(java.util.List<java.lang.String> names)`	Returns vector of symbolic names captured in loadFromCSV()
`long`	`getNativeObjAddr()`
`Mat`	`getNormCatResponses()`
`int`	`getNSamples()`
`int`	`getNTestSamples()`
`int`	`getNTrainSamples()`
`int`	`getNVars()`
`Mat`	`getResponses()`
`int`	`getResponseType()`
`void`	`getSample(Mat varIdx, int sidx, float buf)`
`Mat`	`getSamples()`
`Mat`	`getSampleWeights()`
`static Mat`	`getSubMatrix(Mat matrix, Mat idx, int layout)`	Extract from matrix rows/cols specified by passed indexes.
`static Mat`	`getSubVector(Mat vec, Mat idx)`	Extract from 1D vector elements specified by passed indexes.
`Mat`	`getTestNormCatResponses()`
`Mat`	`getTestResponses()`
`Mat`	`getTestSampleIdx()`
`Mat`	`getTestSamples()`	Returns matrix of test samples
`Mat`	`getTestSampleWeights()`
`Mat`	`getTrainNormCatResponses()`	Returns the vector of normalized categorical responses The function returns vector of responses.
`Mat`	`getTrainResponses()`	Returns the vector of responses The function returns ordered or the original categorical responses.
`Mat`	`getTrainSampleIdx()`
`Mat`	`getTrainSamples()`	Returns matrix of train samples transposed.
`Mat`	`getTrainSamples(int layout)`	Returns matrix of train samples
`Mat`	`getTrainSamples(int layout, boolean compressSamples)`	Returns matrix of train samples
`Mat`	`getTrainSamples(int layout, boolean compressSamples, boolean compressVars)`	Returns matrix of train samples
`Mat`	`getTrainSampleWeights()`
`void`	`getValues(int vi, Mat sidx, float values)`
`Mat`	`getVarIdx()`
`Mat`	`getVarSymbolFlags()`
`Mat`	`getVarType()`
`void`	`setTrainTestSplit(int count)`	Splits the training data into the training and test parts SEE: TrainData::setTrainTestSplitRatio
`void`	`setTrainTestSplit(int count, boolean shuffle)`	Splits the training data into the training and test parts SEE: TrainData::setTrainTestSplitRatio
`void`	`setTrainTestSplitRatio(double ratio)`	Splits the training data into the training and test parts The function selects a subset of specified relative size and then returns it as the training set.
`void`	`setTrainTestSplitRatio(double ratio, boolean shuffle)`	Splits the training data into the training and test parts The function selects a subset of specified relative size and then returns it as the training set.
`void`	`shuffleTrainTest()`

Methods inherited from class java.lang.Object
clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - nativeObj
```
protected final long nativeObj
```
- Constructor Detail
  - TrainData
```
protected TrainData(long addr)
```
- Method Detail
  - getNativeObjAddr
```
public long getNativeObjAddr()
```
  - __fromPtr__
```
public static TrainData __fromPtr__(long addr)
```
  - getLayout
```
public int getLayout()
```
  - getNTrainSamples
```
public int getNTrainSamples()
```
  - getNTestSamples
```
public int getNTestSamples()
```
  - getNSamples
```
public int getNSamples()
```
  - getNVars
```
public int getNVars()
```
  - getNAllVars
```
public int getNAllVars()
```
  - getSample
```
public void getSample(Mat varIdx,
                      int sidx,
                      float buf)
```
  - getSamples
```
public Mat getSamples()
```
  - getMissing
```
public Mat getMissing()
```
  - getTrainSamples
```
public Mat getTrainSamples(int layout,
                           boolean compressSamples,
                           boolean compressVars)
```
    Returns matrix of train samples
    
    Parameters:
    
    layout - The requested layout. If it's different from the initial one, the matrix is transposed. See ml::SampleTypes.
    
    compressSamples - if true, the function returns only the training samples (specified by sampleIdx)
    
    compressVars - if true, the function returns the shorter training samples, containing only the active variables. In current implementation the function tries to avoid physical data copying and returns the matrix stored inside TrainData (unless the transposition or compression is needed).
    
    Returns:
    
    automatically generated
  - getTrainSamples
```
public Mat getTrainSamples(int layout,
                           boolean compressSamples)
```
    Returns matrix of train samples
    
    Parameters:
    
    layout - The requested layout. If it's different from the initial one, the matrix is transposed. See ml::SampleTypes.
    
    compressSamples - if true, the function returns only the training samples (specified by sampleIdx) the active variables. In current implementation the function tries to avoid physical data copying and returns the matrix stored inside TrainData (unless the transposition or compression is needed).
    
    Returns:
    
    automatically generated
  - getTrainSamples
```
public Mat getTrainSamples(int layout)
```
    Returns matrix of train samples
    
    Parameters:
    
    layout - The requested layout. If it's different from the initial one, the matrix is transposed. See ml::SampleTypes. sampleIdx) the active variables. In current implementation the function tries to avoid physical data copying and returns the matrix stored inside TrainData (unless the transposition or compression is needed).
    
    Returns:
    
    automatically generated
  - getTrainSamples
```
public Mat getTrainSamples()
```
    Returns matrix of train samples transposed. See ml::SampleTypes. sampleIdx) the active variables. In current implementation the function tries to avoid physical data copying and returns the matrix stored inside TrainData (unless the transposition or compression is needed).
    
    Returns:
    
    automatically generated
  - getTrainResponses
```
public Mat getTrainResponses()
```
    Returns the vector of responses The function returns ordered or the original categorical responses. Usually it's used in regression algorithms.
    
    Returns:
    
    automatically generated
  - getTrainNormCatResponses
```
public Mat getTrainNormCatResponses()
```
    Returns the vector of normalized categorical responses The function returns vector of responses. Each response is integer from 0 to `<number of classes>-1`. The actual label value can be retrieved then from the class label vector, see TrainData::getClassLabels.
    
    Returns:
    
    automatically generated
  - getTestResponses
```
public Mat getTestResponses()
```
  - getTestNormCatResponses
```
public Mat getTestNormCatResponses()
```
  - getResponses
```
public Mat getResponses()
```
  - getNormCatResponses
```
public Mat getNormCatResponses()
```
  - getSampleWeights
```
public Mat getSampleWeights()
```
  - getTrainSampleWeights
```
public Mat getTrainSampleWeights()
```
  - getTestSampleWeights
```
public Mat getTestSampleWeights()
```
  - getVarIdx
```
public Mat getVarIdx()
```
  - getVarType
```
public Mat getVarType()
```
  - getVarSymbolFlags
```
public Mat getVarSymbolFlags()
```
  - getResponseType
```
public int getResponseType()
```
  - getTrainSampleIdx
```
public Mat getTrainSampleIdx()
```
  - getTestSampleIdx
```
public Mat getTestSampleIdx()
```
  - getValues
```
public void getValues(int vi,
                      Mat sidx,
                      float values)
```
  - getDefaultSubstValues
```
public Mat getDefaultSubstValues()
```
  - getCatCount
```
public int getCatCount(int vi)
```
  - getClassLabels
```
public Mat getClassLabels()
```
    Returns the vector of class labels The function returns vector of unique labels occurred in the responses.
    
    Returns:
    
    automatically generated
  - getCatOfs
```
public Mat getCatOfs()
```
  - getCatMap
```
public Mat getCatMap()
```
  - setTrainTestSplit
```
public void setTrainTestSplit(int count,
                              boolean shuffle)
```
    Splits the training data into the training and test parts SEE: TrainData::setTrainTestSplitRatio
    
    Parameters:
    
    count - automatically generated
    
    shuffle - automatically generated
  - setTrainTestSplit
```
public void setTrainTestSplit(int count)
```
    Splits the training data into the training and test parts SEE: TrainData::setTrainTestSplitRatio
    
    Parameters:
    
    count - automatically generated
  - setTrainTestSplitRatio
```
public void setTrainTestSplitRatio(double ratio,
                                   boolean shuffle)
```
    Splits the training data into the training and test parts The function selects a subset of specified relative size and then returns it as the training set. If the function is not called, all the data is used for training. Please, note that for each of TrainData::getTrain\* there is corresponding TrainData::getTest\*, so that the test subset can be retrieved and processed as well. SEE: TrainData::setTrainTestSplit
    
    Parameters:
    
    ratio - automatically generated
    
    shuffle - automatically generated
  - setTrainTestSplitRatio
```
public void setTrainTestSplitRatio(double ratio)
```
    Splits the training data into the training and test parts The function selects a subset of specified relative size and then returns it as the training set. If the function is not called, all the data is used for training. Please, note that for each of TrainData::getTrain\* there is corresponding TrainData::getTest\*, so that the test subset can be retrieved and processed as well. SEE: TrainData::setTrainTestSplit
    
    Parameters:
    
    ratio - automatically generated
  - shuffleTrainTest
```
public void shuffleTrainTest()
```
  - getTestSamples
```
public Mat getTestSamples()
```
    Returns matrix of test samples
    
    Returns:
    
    automatically generated
  - getNames
```
public void getNames(java.util.List<java.lang.String> names)
```
    Returns vector of symbolic names captured in loadFromCSV()
    
    Parameters:
    
    names - automatically generated
  - getSubVector
```
public static Mat getSubVector(Mat vec,
                               Mat idx)
```
    Extract from 1D vector elements specified by passed indexes.
    
    Parameters:
    
    vec - input vector (supported types: CV_32S, CV_32F, CV_64F)
    
    idx - 1D index vector
    
    Returns:
    
    automatically generated
  - getSubMatrix
```
public static Mat getSubMatrix(Mat matrix,
                               Mat idx,
                               int layout)
```
    Extract from matrix rows/cols specified by passed indexes.
    
    Parameters:
    
    matrix - input matrix (supported types: CV_32S, CV_32F, CV_64F)
    
    idx - 1D index vector
    
    layout - specifies to extract rows (cv::ml::ROW_SAMPLES) or to extract columns (cv::ml::COL_SAMPLES)
    
    Returns:
    
    automatically generated
  - create
```
public static TrainData create(Mat samples,
                               int layout,
                               Mat responses,
                               Mat varIdx,
                               Mat sampleIdx,
                               Mat sampleWeights,
                               Mat varType)
```
    Creates training data from in-memory arrays.
    
    Parameters:
    
    samples - matrix of samples. It should have CV_32F type.
    
    layout - see ml::SampleTypes.
    
    responses - matrix of responses. If the responses are scalar, they should be stored as a single row or as a single column. The matrix should have type CV_32F or CV_32S (in the former case the responses are considered as ordered by default; in the latter case - as categorical)
    
    varIdx - vector specifying which variables to use for training. It can be an integer vector (CV_32S) containing 0-based variable indices or byte vector (CV_8U) containing a mask of active variables.
    
    sampleIdx - vector specifying which samples to use for training. It can be an integer vector (CV_32S) containing 0-based sample indices or byte vector (CV_8U) containing a mask of training samples.
    
    sampleWeights - optional vector with weights for each sample. It should have CV_32F type.
    
    varType - optional vector of type CV_8U and size `<number_of_variables_in_samples> + <number_of_variables_in_responses>`, containing types of each input and output variable. See ml::VariableTypes.
    
    Returns:
    
    automatically generated
  - create
```
public static TrainData create(Mat samples,
                               int layout,
                               Mat responses,
                               Mat varIdx,
                               Mat sampleIdx,
                               Mat sampleWeights)
```
    Creates training data from in-memory arrays.
    
    Parameters:
    
    samples - matrix of samples. It should have CV_32F type.
    
    layout - see ml::SampleTypes.
    
    responses - matrix of responses. If the responses are scalar, they should be stored as a single row or as a single column. The matrix should have type CV_32F or CV_32S (in the former case the responses are considered as ordered by default; in the latter case - as categorical)
    
    varIdx - vector specifying which variables to use for training. It can be an integer vector (CV_32S) containing 0-based variable indices or byte vector (CV_8U) containing a mask of active variables.
    
    sampleIdx - vector specifying which samples to use for training. It can be an integer vector (CV_32S) containing 0-based sample indices or byte vector (CV_8U) containing a mask of training samples.
    
    sampleWeights - optional vector with weights for each sample. It should have CV_32F type. <number_of_variables_in_responses>`, containing types of each input and output variable. See ml::VariableTypes.
    
    Returns:
    
    automatically generated
  - create
```
public static TrainData create(Mat samples,
                               int layout,
                               Mat responses,
                               Mat varIdx,
                               Mat sampleIdx)
```
    Creates training data from in-memory arrays.
    
    Parameters:
    
    samples - matrix of samples. It should have CV_32F type.
    
    layout - see ml::SampleTypes.
    
    responses - matrix of responses. If the responses are scalar, they should be stored as a single row or as a single column. The matrix should have type CV_32F or CV_32S (in the former case the responses are considered as ordered by default; in the latter case - as categorical)
    
    varIdx - vector specifying which variables to use for training. It can be an integer vector (CV_32S) containing 0-based variable indices or byte vector (CV_8U) containing a mask of active variables.
    
    sampleIdx - vector specifying which samples to use for training. It can be an integer vector (CV_32S) containing 0-based sample indices or byte vector (CV_8U) containing a mask of training samples. <number_of_variables_in_responses>`, containing types of each input and output variable. See ml::VariableTypes.
    
    Returns:
    
    automatically generated
  - create
```
public static TrainData create(Mat samples,
                               int layout,
                               Mat responses,
                               Mat varIdx)
```
    Creates training data from in-memory arrays.
    
    Parameters:
    
    samples - matrix of samples. It should have CV_32F type.
    
    layout - see ml::SampleTypes.
    
    responses - matrix of responses. If the responses are scalar, they should be stored as a single row or as a single column. The matrix should have type CV_32F or CV_32S (in the former case the responses are considered as ordered by default; in the latter case - as categorical)
    
    varIdx - vector specifying which variables to use for training. It can be an integer vector (CV_32S) containing 0-based variable indices or byte vector (CV_8U) containing a mask of active variables. vector (CV_32S) containing 0-based sample indices or byte vector (CV_8U) containing a mask of training samples. <number_of_variables_in_responses>`, containing types of each input and output variable. See ml::VariableTypes.
    
    Returns:
    
    automatically generated
  - create
```
public static TrainData create(Mat samples,
                               int layout,
                               Mat responses)
```
    Creates training data from in-memory arrays.
    
    Parameters:
    
    samples - matrix of samples. It should have CV_32F type.
    
    layout - see ml::SampleTypes.
    
    responses - matrix of responses. If the responses are scalar, they should be stored as a single row or as a single column. The matrix should have type CV_32F or CV_32S (in the former case the responses are considered as ordered by default; in the latter case - as categorical) (CV_32S) containing 0-based variable indices or byte vector (CV_8U) containing a mask of active variables. vector (CV_32S) containing 0-based sample indices or byte vector (CV_8U) containing a mask of training samples. <number_of_variables_in_responses>`, containing types of each input and output variable. See ml::VariableTypes.
    
    Returns:
    
    automatically generated
  - finalize
```
protected void finalize()
                 throws java.lang.Throwable
```
    Overrides:
    
    finalize in class java.lang.Object
    
    Throws:
    
    java.lang.Throwable

Class TrainData

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

nativeObj

Constructor Detail

TrainData

Method Detail

getNativeObjAddr

__fromPtr__

getLayout

getNTrainSamples

getNTestSamples

getNSamples

getNVars

getNAllVars

getSample

getSamples

getMissing

getTrainSamples

getTrainSamples

getTrainSamples

getTrainSamples

getTrainResponses

getTrainNormCatResponses

getTestResponses

getTestNormCatResponses

getResponses

getNormCatResponses

getSampleWeights

getTrainSampleWeights

getTestSampleWeights

getVarIdx

getVarType

getVarSymbolFlags

getResponseType

getTrainSampleIdx

getTestSampleIdx

getValues

getDefaultSubstValues

getCatCount

getClassLabels

getCatOfs

getCatMap

setTrainTestSplit

setTrainTestSplit

setTrainTestSplitRatio

setTrainTestSplitRatio

shuffleTrainTest

getTestSamples

getNames

getSubVector

getSubMatrix

create

create

create

create

create

finalize

fromPtr