DataUtils Namespace Reference

Functions
bool	checkRelativeDifference (const OutputData< double > &dat, const OutputData< double > &ref, const double threshold)
	Returns true is relative difference is below threshold; prints informative output. More...
void	coordinateFromBinf (double &x, double &y, const OutputData< double > &data)
	Transforms x,y coordinate from bin-fraction-coordinates to OutputData's axes coordinates. More...
double	coordinateFromBinf (double value, const IAxis &axis)
	Transforms bin-fraction-coordinate into axis coordinate. More...
void	coordinateToBinf (double &x, double &y, const OutputData< double > &data)
	Transforms x,y coordinate from OutputData axes coordinates to bin-fraction-coordinates. More...
double	coordinateToBinf (double coordinate, const IAxis &axis)
	Transforms coordinate on axis into the bin-fraction-coordinate. More...
std::vector< std::vector< double > >	create2DArrayfromOutputData (const OutputData< double > &data)
	Creates a vector of vectors of double (2D Array) from OutputData. More...
std::unique_ptr< OutputData< double > >	createClippedDataSet (const OutputData< double > &origin, double x1, double y1, double x2, double y2)
	Returns new IntensityData objects which axes clipped to represent the specified rectangle. More...
std::unique_ptr< OutputData< double > >	createFFT (const OutputData< double > &data)
	Creates Fourier Transform (OutputData format) of intensity map (OutputData format). More...
std::unique_ptr< OutputData< double > >	createOutputDatafrom2DArray (const std::vector< std::vector< double >> &array_2d)
	Creates OutputData from a 2D Array. More...
std::unique_ptr< OutputData< double > >	createRearrangedDataSet (const OutputData< double > &data, int n)
	Returns new object with input data rotated by n*90 deg counterclockwise (n > 0) or clockwise (n < 0) Axes are swapped if the data is effectively rotated by 90 or 270 degrees Applicable to 2D arrays only. More...
std::unique_ptr< OutputData< double > >	createRelativeDifferenceData (const OutputData< double > &data, const OutputData< double > &reference)
OutputData< double > *	importArrayToOutputData (const std::vector< double > &vec)
	Reads 1D array of doubles to Python, for use in persistence test. More...
OutputData< double > *	importArrayToOutputData (const std::vector< std::vector< double >> &vec)
	Reads 2D array of doubles to Python, for use in persistence test. More...
double	relativeDataDifference (const OutputData< double > &dat, const OutputData< double > &ref)
	Returns relative difference between two data sets sum(dat[i] - ref[i])/ref[i]). More...

Function Documentation

checkRelativeDifference()

bool DataUtils::checkRelativeDifference	(	const OutputData< double > &	dat,
		const OutputData< double > &	ref,
		const double	threshold
	)

Returns true is relative difference is below threshold; prints informative output.

Definition at line 51 of file DataUtils.cpp.

{
    const double diff = relativeDataDifference(dat, ref);
    if (diff > threshold) {
        std::cerr << "FAILED: relative deviation of dat from ref is " << diff
                  << ", above given threshold " << threshold << std::endl;
        return false;
    }
    if (diff)
        std::cerr << "- OK: relative deviation of dat from ref is " << diff
                  << ", within given threshold " << threshold << std::endl;
    else
        std::cout << "- OK: dat = ref\n";
    return true;
}

References relativeDataDifference().

Referenced by HistoUtils::agreesWithReference().

Here is the call graph for this function:

coordinateFromBinf() [1/2]

void DataUtils::coordinateFromBinf	(	double &	x,
		double &	y,
		const OutputData< double > &	data
	)

Transforms x,y coordinate from bin-fraction-coordinates to OutputData's axes coordinates.

Definition at line 202 of file DataUtils.cpp.

{
    x = coordinateFromBinf(x, data.axis(0));
    y = coordinateFromBinf(y, data.axis(1));
}

References OutputData< T >::axis(), and coordinateFromBinf().

Here is the call graph for this function:

coordinateFromBinf() [2/2]

double DataUtils::coordinateFromBinf	(	double	value,
		const IAxis &	axis
	)

Transforms bin-fraction-coordinate into axis coordinate.

Definition at line 177 of file DataUtils.cpp.

{
    int index = static_cast<int>(value);
 
    double result(0);
    if (index < 0) {
        Bin1D bin = axis.bin(0);
        result = bin.m_lower + value * bin.binSize();
    } else if (index >= static_cast<int>(axis.size())) {
        Bin1D bin = axis.bin(axis.size() - 1);
        result = bin.m_upper + (value - axis.size()) * bin.binSize();
    } else {
        Bin1D bin = axis.bin(static_cast<size_t>(index));
        result = bin.m_lower + (value - static_cast<double>(index)) * bin.binSize();
    }
 
    return result;
}

References IAxis::bin(), Bin1D::binSize(), Bin1D::m_lower, Bin1D::m_upper, and IAxis::size().

Referenced by MaskUnitsConverter::convert(), MaskUnitsConverter::convertMask(), and coordinateFromBinf().

Here is the call graph for this function:

coordinateToBinf() [1/2]

void DataUtils::coordinateToBinf	(	double &	x,
		double &	y,
		const OutputData< double > &	data
	)

Transforms x,y coordinate from OutputData axes coordinates to bin-fraction-coordinates.

Definition at line 196 of file DataUtils.cpp.

{
    x = coordinateToBinf(x, data.axis(0));
    y = coordinateToBinf(y, data.axis(1));
}

References OutputData< T >::axis(), and coordinateToBinf().

Here is the call graph for this function:

coordinateToBinf() [2/2]

double DataUtils::coordinateToBinf	(	double	coordinate,
		const IAxis &	axis
	)

Transforms coordinate on axis into the bin-fraction-coordinate.

Definition at line 169 of file DataUtils.cpp.

{
    size_t index = axis.findClosestIndex(coordinate);
    Bin1D bin = axis.bin(index);
    double f = (coordinate - bin.m_lower) / bin.binSize();
    return static_cast<double>(index) + f;
}

References IAxis::bin(), Bin1D::binSize(), IAxis::findClosestIndex(), and Bin1D::m_lower.

Referenced by MaskUnitsConverter::convert(), MaskUnitsConverter::convertMask(), and coordinateToBinf().

Here is the call graph for this function:

create2DArrayfromOutputData()

std::vector< std::vector< double > > DataUtils::create2DArrayfromOutputData

(

const OutputData< double > &

data

)

Creates a vector of vectors of double (2D Array) from OutputData.

Definition at line 209 of file DataUtils.cpp.

{
    if (data.rank() != 2)
        throw std::runtime_error("DataUtils::create2DArrayfromOutputData() -> "
                                 "Error! Works only on two-dimensional data");
 
    std::vector<std::vector<double>> array_2d;
    std::vector<double> row_vec; // row vector for constructing each row of 2D array
 
    size_t nrows = data.axis(0).size();
    size_t ncols = data.axis(1).size();
 
    size_t it = 0; // iterator of 'data'
    for (size_t row = 0; row < nrows; row++) {
        row_vec.clear();
        for (size_t col = 0; col < ncols; col++) {
            row_vec.push_back(data[it]);
            it++;
        }
        array_2d.push_back(row_vec);
    }
 
    return array_2d;
}

References OutputData< T >::axis(), OutputData< T >::rank(), and IAxis::size().

Referenced by createFFT().

Here is the call graph for this function:

createClippedDataSet()

std::unique_ptr< OutputData< double > > DataUtils::createClippedDataSet	(	const OutputData< double > &	origin,
		double	x1,
		double	y1,
		double	x2,
		double	y2
	)

Returns new IntensityData objects which axes clipped to represent the specified rectangle.

Definition at line 128 of file DataUtils.cpp.

{
    if (origin.rank() != 2)
        throw std::runtime_error("DataUtils::createClippedData()"
                                 " -> Error! Works only on two-dimensional data");
 
    std::unique_ptr<OutputData<double>> result(new OutputData<double>);
    for (size_t i_axis = 0; i_axis < origin.rank(); i_axis++) {
        const IAxis& axis = origin.axis(i_axis);
        IAxis* new_axis;
        if (i_axis == 0)
            new_axis = axis.createClippedAxis(x1, x2);
        else
            new_axis = axis.createClippedAxis(y1, y2);
        result->addAxis(*new_axis);
        delete new_axis;
    }
    result->setAllTo(0.0);
 
    OutputData<double>::const_iterator it_origin = origin.begin();
    OutputData<double>::iterator it_result = result->begin();
    while (it_origin != origin.end()) {
        double x = origin.getAxisValue(it_origin.getIndex(), 0);
        double y = origin.getAxisValue(it_origin.getIndex(), 1);
        if (result->axis(0).contains(x) && result->axis(1).contains(y)) {
            *it_result = *it_origin;
            ++it_result;
        }
        ++it_origin;
    }
 
    return result;
}

References OutputData< T >::axis(), OutputData< T >::begin(), IAxis::createClippedAxis(), OutputData< T >::end(), OutputData< T >::getAxisValue(), and OutputData< T >::rank().

Here is the call graph for this function:

createFFT()

std::unique_ptr< OutputData< double > > DataUtils::createFFT

(

const OutputData< double > &

data

)

Creates Fourier Transform (OutputData format) of intensity map (OutputData format).

Definition at line 256 of file DataUtils.cpp.

{
    auto array_2d = DataUtils::create2DArrayfromOutputData(data);
    auto fft_array_2d = FT2DArray(array_2d);
    return DataUtils::createOutputDatafrom2DArray(fft_array_2d);
}

References create2DArrayfromOutputData(), and createOutputDatafrom2DArray().

Referenced by IntensityDataFFTPresenter::fftItem().

Here is the call graph for this function:

createOutputDatafrom2DArray()

std::unique_ptr< OutputData< double > > DataUtils::createOutputDatafrom2DArray

(

const std::vector< std::vector< double >> &

array_2d

)

Creates OutputData from a 2D Array.

Definition at line 235 of file DataUtils.cpp.

{
    std::unique_ptr<OutputData<double>> result(new OutputData<double>);
    size_t nrows = array_2d.size();
    size_t ncols = array_2d[0].size();
 
    result->addAxis("x", nrows, 0.0, double(nrows));
    result->addAxis("y", ncols, 0.0, double(ncols));
    std::vector<unsigned> axes_indices(2);
    for (unsigned row = 0; row < nrows; row++) {
        for (unsigned col = 0; col < ncols; col++) {
            axes_indices[0] = row;
            axes_indices[1] = col;
            size_t global_index = result->toGlobalIndex(axes_indices);
            (*result)[global_index] = array_2d[row][col];
        }
    }
 
    return result;
}

Referenced by createFFT().

createRearrangedDataSet()

std::unique_ptr< OutputData< double > > DataUtils::createRearrangedDataSet	(	const OutputData< double > &	data,
		int	n
	)

Returns new object with input data rotated by n*90 deg counterclockwise (n > 0) or clockwise (n < 0) Axes are swapped if the data is effectively rotated by 90 or 270 degrees Applicable to 2D arrays only.

Definition at line 82 of file DataUtils.cpp.

{
    if (data.rank() != 2)
        throw std::runtime_error("DataUtils::rotateDataByN90Deg()"
                                 " -> Error! Works only on two-dimensional data");
    n = (4 + n % 4) % 4;
    if (n == 0)
        return std::unique_ptr<OutputData<double>>(data.clone());
    std::unique_ptr<OutputData<double>> output(new OutputData<double>());
 
    // swapping axes if necessary
    const IAxis& x_axis = data.axis(0);
    const IAxis& y_axis = data.axis(1);
    output->addAxis(n == 2 ? x_axis : y_axis);
    output->addAxis(n == 2 ? y_axis : x_axis);
 
    // creating index mapping
    std::function<void(std::vector<int>&)> index_mapping;
    if (n == 2) {
        const int end_bin_x = static_cast<int>(x_axis.size()) - 1;
        const int end_bin_y = static_cast<int>(y_axis.size()) - 1;
        index_mapping = [end_bin_x, end_bin_y](std::vector<int>& inds) {
            inds[0] = end_bin_x - inds[0];
            inds[1] = end_bin_y - inds[1];
        };
    } else {
        const size_t rev_axis_i = n % 3;
        const size_t end_bin = data.axis(rev_axis_i).size() - 1;
        index_mapping = [rev_axis_i, end_bin](std::vector<int>& inds) {
            const int tm_index = inds[rev_axis_i];
            inds[rev_axis_i] = inds[rev_axis_i ^ 1];
            inds[rev_axis_i ^ 1] = static_cast<int>(end_bin) - tm_index;
        };
    }
 
    for (size_t index = 0, size = data.getAllocatedSize(); index < size; ++index) {
        std::vector<int> axis_inds = data.getAxesBinIndices(index);
        index_mapping(axis_inds);
        size_t output_index = output->toGlobalIndex(
            {static_cast<unsigned>(axis_inds[0]), static_cast<unsigned>(axis_inds[1])});
        (*output)[output_index] = data[index];
    }
    return output;
}

References OutputData< T >::axis(), OutputData< T >::clone(), OutputData< T >::getAllocatedSize(), OutputData< T >::getAxesBinIndices(), OutputData< T >::rank(), and IAxis::size().

Referenced by RealDataItem::rotateData().

Here is the call graph for this function:

createRelativeDifferenceData()

std::unique_ptr< OutputData< double > > DataUtils::createRelativeDifferenceData	(	const OutputData< double > &	data,
		const OutputData< double > &	reference
	)

Definition at line 69 of file DataUtils.cpp.

{
    if (!data.hasSameDimensions(reference))
        throw std::runtime_error("DataUtils::createRelativeDifferenceData() -> "
                                 "Error. Different dimensions of data and reference.");
    std::unique_ptr<OutputData<double>> result(reference.clone());
    for (size_t i = 0; i < result->getAllocatedSize(); ++i)
        (*result)[i] = Numeric::GetRelativeDifference(data[i], reference[i]);
    return result;
}

References OutputData< T >::clone(), Numeric::GetRelativeDifference(), and OutputData< T >::hasSameDimensions().

Referenced by DiffItemController::updateDiffData().

Here is the call graph for this function:

importArrayToOutputData() [1/2]

OutputData< double > * DataUtils::importArrayToOutputData

(

const std::vector< double > &

vec

)

Reads 1D array of doubles to Python, for use in persistence test.

Definition at line 263 of file DataUtils.cpp.

{
    return ArrayUtils::createData(vec).release();
}

References ArrayUtils::createData().

Here is the call graph for this function:

importArrayToOutputData() [2/2]

OutputData< double > * DataUtils::importArrayToOutputData

(

const std::vector< std::vector< double >> &

vec

)

Reads 2D array of doubles to Python, for use in persistence test.

Definition at line 268 of file DataUtils.cpp.

{
    return ArrayUtils::createData(vec).release();
}

References ArrayUtils::createData().

Here is the call graph for this function:

relativeDataDifference()

double DataUtils::relativeDataDifference	(	const OutputData< double > &	dat,
		const OutputData< double > &	ref
	)

Returns relative difference between two data sets sum(dat[i] - ref[i])/ref[i]).

Definition at line 35 of file DataUtils.cpp.

{
    if (!dat.hasSameDimensions(ref))
        throw std::runtime_error("OutputData dimension differs from reference");
 
    double diff = 0.0;
    for (size_t i = 0; i < dat.getAllocatedSize(); ++i)
        diff += Numeric::GetRelativeDifference(dat[i], ref[i]);
    diff /= dat.getAllocatedSize();
    if (std::isnan(diff))
        throw std::runtime_error("diff=NaN!");
    return diff;
}

References OutputData< T >::getAllocatedSize(), Numeric::GetRelativeDifference(), and OutputData< T >::hasSameDimensions().

Referenced by checkRelativeDifference(), and HistoUtils::getRelativeDifference().

Here is the call graph for this function: