void ExportFileFunctions::outputXThetaYRadiusValues (const DocumentModelExportFormat &modelExportOverride,
const DocumentModelCoords &modelCoords,
const MainWindowModel &modelMainWindow,
const QStringList &curvesIncluded,
const ExportValuesXOrY &xThetaValuesMerged,
const Transformation &transformation,
QVector<QVector<QString*> > &yRadiusValues,
const QString &delimiter,
QTextStream &str) const
{
LOG4CPP_INFO_S ((*mainCat)) << "ExportFileFunctions::outputXThetaYRadiusValues";
// Header
if (modelExportOverride.header() != EXPORT_HEADER_NONE) {
if (modelExportOverride.header() == EXPORT_HEADER_GNUPLOT) {
str << curveSeparator (str.string());
str << gnuplotComment();
}
str << modelExportOverride.xLabel();
QStringList::const_iterator itrHeader;
for (itrHeader = curvesIncluded.begin(); itrHeader != curvesIncluded.end(); itrHeader++) {
QString curveName = *itrHeader;
str << delimiter << curveName;
}
str << "\n";
}
FormatCoordsUnits format;
const double DUMMY_Y_RADIUS = 1.0;
for (int row = 0; row < xThetaValuesMerged.count(); row++) {
if (rowHasAtLeastOneYRadiusEntry (yRadiusValues,
row)) {
double xTheta = xThetaValuesMerged.at (row);
// Output x/theta value for this row
QString xThetaString, yRadiusString;
format.unformattedToFormatted (xTheta,
DUMMY_Y_RADIUS,
modelCoords,
modelMainWindow,
xThetaString,
yRadiusString,
transformation);
str << xThetaString;
for (int col = 0; col < yRadiusValues.count(); col++) {
str << delimiter << *(yRadiusValues [col] [row]);
}
str << "\n";
}
}
}
void ExportFileFunctions::exportToFile (const DocumentModelExportFormat &modelExportOverride,
const Document &document,
const MainWindowModel &modelMainWindow,
const Transformation &transformation,
QTextStream &str) const
{
LOG4CPP_INFO_S ((*mainCat)) << "ExportFileFunctions::exportToFile";
// Identify curves to be included
QStringList curvesIncluded = curvesToInclude (modelExportOverride,
document,
document.curvesGraphsNames(),
CONNECT_AS_FUNCTION_SMOOTH,
CONNECT_AS_FUNCTION_STRAIGHT);
// Delimiter
const QString delimiter = exportDelimiterToText (modelExportOverride.delimiter());
// Get x/theta values to be used
CallbackGatherXThetaValuesFunctions ftor (modelExportOverride,
curvesIncluded,
transformation);
Functor2wRet<const QString &, const Point &, CallbackSearchReturn> ftorWithCallback = functor_ret (ftor,
&CallbackGatherXThetaValuesFunctions::callback);
document.iterateThroughCurvesPointsGraphs(ftorWithCallback);
ExportXThetaValuesMergedFunctions exportXTheta (modelExportOverride,
ftor.xThetaValuesRaw(),
transformation);
ExportValuesXOrY xThetaValuesMerged = exportXTheta.xThetaValues ();
// Skip if every curve was a relation
if (xThetaValuesMerged.count() > 0) {
// Export in one of two layouts
if (modelExportOverride.layoutFunctions() == EXPORT_LAYOUT_ALL_PER_LINE) {
exportAllPerLineXThetaValuesMerged (modelExportOverride,
document,
modelMainWindow,
curvesIncluded,
xThetaValuesMerged,
delimiter,
transformation,
str);
} else {
exportOnePerLineXThetaValuesMerged (modelExportOverride,
document,
modelMainWindow,
curvesIncluded,
xThetaValuesMerged,
delimiter,
transformation,
str);
}
}
}
QStringList ExportFileAbstractBase::curvesToInclude (const DocumentModelExportFormat &modelExportOverride,
const Document &document,
const QStringList &curvesGraphsNames,
CurveConnectAs curveConnectAs1,
CurveConnectAs curveConnectAs2) const
{
LOG4CPP_INFO_S ((*mainCat)) << "ExportFileAbstractBase::curvesToInclude";
QStringList curvesToInclude;
// Build a list of curves to include by subtracting the excluded curves from the the complete list.
// Special case is to use only first included curve if appropriate flag is set
QStringList::const_iterator itr;
for (itr = curvesGraphsNames.begin(); itr != curvesGraphsNames.end(); itr++) {
QString curvesGraphName = *itr;
if (!modelExportOverride.curveNamesNotExported().contains (curvesGraphName)) {
const Curve *curve = document.curveForCurveName(curvesGraphName);
ENGAUGE_CHECK_PTR (curve);
// Not excluded which means it gets included, but only if it is a function
if (curve->curveStyle().lineStyle().curveConnectAs() == curveConnectAs1 ||
curve->curveStyle().lineStyle().curveConnectAs() == curveConnectAs2) {
curvesToInclude.push_back (curvesGraphName);
}
}
}
return curvesToInclude;
}
int ExportFileRelations::maxColumnSizeAllocation (const DocumentModelExportFormat &modelExport,
const Document &document,
const Transformation &transformation,
const QStringList &curvesIncluded) const
{
LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::maxColumnSizeAllocation";
int maxColumnSize = 0;
// The curve processing logic here is mirrored in loadXThetaYRadiusValues so the array allocations are in sync
for (int ic = 0; ic < curvesIncluded.count(); ic++) {
const QString curveName = curvesIncluded.at (ic);
const Curve *curve = document.curveForCurveName (curveName);
const Points points = curve->points ();
if (modelExport.pointsSelectionRelations() == EXPORT_POINTS_SELECTION_RELATIONS_RAW) {
// No interpolation. Raw points
maxColumnSize = qMax (maxColumnSize,
points.count());
} else {
const LineStyle &lineStyle = document.modelCurveStyles().lineStyle(curveName);
// Interpolation. Points are taken approximately every every modelExport.pointsIntervalRelations
ExportValuesOrdinal ordinals = ordinalsAtIntervals (modelExport.pointsIntervalRelations(),
modelExport.pointsIntervalUnitsRelations(),
lineStyle.curveConnectAs(),
transformation,
points);
maxColumnSize = qMax (maxColumnSize,
ordinals.count());
}
}
return maxColumnSize;
}
void ExportFileFunctions::loadYRadiusValues (const DocumentModelExportFormat &modelExportOverride,
const Document &document,
const MainWindowModel &modelMainWindow,
const QStringList &curvesIncluded,
const Transformation &transformation,
const ExportValuesXOrY &xThetaValues,
QVector<QVector<QString*> > &yRadiusValues) const
{
LOG4CPP_INFO_S ((*mainCat)) << "ExportFileFunctions::loadYRadiusValues";
// Loop through curves
int curveCount = curvesIncluded.count();
for (int col = 0; col < curveCount; col++) {
const QString curveName = curvesIncluded.at (col);
const Curve *curve = document.curveForCurveName (curveName);
const Points points = curve->points ();
if (modelExportOverride.pointsSelectionFunctions() == EXPORT_POINTS_SELECTION_FUNCTIONS_RAW) {
// No interpolation. Raw points
loadYRadiusValuesForCurveRaw (document.modelCoords(),
modelMainWindow,
points,
xThetaValues,
transformation,
yRadiusValues [col]);
} else {
// Interpolation
if (curve->curveStyle().lineStyle().curveConnectAs() == CONNECT_AS_FUNCTION_SMOOTH) {
loadYRadiusValuesForCurveInterpolatedSmooth (document.modelCoords(),
modelMainWindow,
points,
xThetaValues,
transformation,
yRadiusValues [col]);
} else {
loadYRadiusValuesForCurveInterpolatedStraight (document.modelCoords(),
modelMainWindow,
points,
xThetaValues,
transformation,
yRadiusValues [col]);
}
}
}
}
void ExportFileRelations::exportToFile (const DocumentModelExportFormat &modelExportOverride,
const Document &document,
const MainWindowModel &modelMainWindow,
const Transformation &transformation,
QTextStream &str) const
{
LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::exportToFile";
// Identify curves to be included
QStringList curvesIncluded = curvesToInclude (modelExportOverride,
document,
document.curvesGraphsNames(),
CONNECT_AS_RELATION_SMOOTH,
CONNECT_AS_RELATION_STRAIGHT);
// Delimiter
const QString delimiter = exportDelimiterToText (modelExportOverride.delimiter(),
modelExportOverride.header() == EXPORT_HEADER_GNUPLOT);
// Export in one of two layouts
if (modelExportOverride.layoutFunctions() == EXPORT_LAYOUT_ALL_PER_LINE) {
exportAllPerLineXThetaValuesMerged (modelExportOverride,
document,
modelMainWindow,
curvesIncluded,
delimiter,
transformation,
str);
} else {
exportOnePerLineXThetaValuesMerged (modelExportOverride,
document,
modelMainWindow,
curvesIncluded,
delimiter,
transformation,
str);
}
}
QString ExportFileAbstractBase::wrapInDoubleQuotesIfNeeded (const DocumentModelExportFormat &modelExportOverride,
const QString &valueString) const
{
QString newValueString = valueString;
if ((modelExportOverride.delimiter () == EXPORT_DELIMITER_COMMA) &&
(valueString.indexOf (",") >= 0)) {
// Eliminate ambiguities according to RFC 4180
newValueString = QString ("\"%1\"").arg (valueString);
}
return newValueString;
}
void ExportFileRelations::outputXThetaYRadiusValues (const DocumentModelExportFormat &modelExportOverride,
const QStringList &curvesIncluded,
QVector<QVector<QString*> > &xThetaYRadiusValues,
const QString &delimiter,
QTextStream &str) const
{
LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::outputXThetaYRadiusValues";
// Header
if (modelExportOverride.header() != EXPORT_HEADER_NONE) {
if (modelExportOverride.header() == EXPORT_HEADER_GNUPLOT) {
str << curveSeparator(str.string());
str << gnuplotComment();
}
QString delimiterForRow;
QStringList::const_iterator itr;
for (itr = curvesIncluded.begin(); itr != curvesIncluded.end(); itr++) {
QString curveName = *itr;
str << delimiterForRow << modelExportOverride.xLabel();
delimiterForRow = delimiter;
str << delimiterForRow << curveName;
}
str << "\n";
}
for (int row = 0; row < xThetaYRadiusValues [0].count(); row++) {
QString delimiterForRow;
for (int col = 0; col < xThetaYRadiusValues.count(); col++) {
str << delimiterForRow << *(xThetaYRadiusValues [col] [row]);
delimiterForRow = delimiter;
}
str << "\n";
}
}
void ExportFileFunctions::exportOnePerLineXThetaValuesMerged (const DocumentModelExportFormat &modelExportOverride,
const Document &document,
const MainWindowModel &modelMainWindow,
const QStringList &curvesIncluded,
const ExportValuesXOrY &xThetaValues,
const QString &delimiter,
const Transformation &transformation,
QTextStream &str) const
{
LOG4CPP_INFO_S ((*mainCat)) << "ExportFileFunctions::exportOnePerLineXThetaValuesMerged";
bool isFirst = true;
QStringList::const_iterator itr;
for (itr = curvesIncluded.begin(); itr != curvesIncluded.end(); itr++) {
insertLineSeparator (isFirst,
modelExportOverride.header(),
str);
// This curve
const int CURVE_COUNT = 1;
QString curveIncluded = *itr;
QStringList curvesIncluded (curveIncluded);
int xThetaCount = xThetaValues.count();
QVector<QVector<QString*> > yRadiusValues (CURVE_COUNT, QVector<QString*> (xThetaCount));
initializeYRadiusValues (curvesIncluded,
xThetaValues,
yRadiusValues);
loadYRadiusValues (modelExportOverride,
document,
modelMainWindow,
curvesIncluded,
transformation,
xThetaValues,
yRadiusValues);
outputXThetaYRadiusValues (modelExportOverride,
document.modelCoords(),
modelMainWindow,
curvesIncluded,
xThetaValues,
transformation,
yRadiusValues,
delimiter,
str);
destroy2DArray (yRadiusValues);
}
}
void ExportFileRelations::loadXThetaYRadiusValues (const DocumentModelExportFormat &modelExportOverride,
const Document &document,
const MainWindowModel &modelMainWindow,
const QStringList &curvesIncluded,
const Transformation &transformation,
QVector<QVector<QString*> > &xThetaYRadiusValues) const
{
LOG4CPP_INFO_S ((*mainCat)) << "ExportFileRelations::loadXThetaYRadiusValues";
// The curve processing logic here is mirrored in maxColumnSizeAllocation so the array allocations are in sync
for (int ic = 0; ic < curvesIncluded.count(); ic++) {
int colXTheta = 2 * ic;
int colYRadius = 2 * ic + 1;
const QString curveName = curvesIncluded.at (ic);
const Curve *curve = document.curveForCurveName (curveName);
const Points points = curve->points ();
if (modelExportOverride.pointsSelectionRelations() == EXPORT_POINTS_SELECTION_RELATIONS_RAW) {
// No interpolation. Raw points
loadXThetaYRadiusValuesForCurveRaw (document.modelCoords(),
document.modelGeneral(),
modelMainWindow,
points,
xThetaYRadiusValues [colXTheta],
xThetaYRadiusValues [colYRadius],
transformation);
} else {
const LineStyle &lineStyle = document.modelCurveStyles().lineStyle(curveName);
// Interpolation. Points are taken approximately every every modelExport.pointsIntervalRelations
ExportValuesOrdinal ordinals = ordinalsAtIntervals (modelExportOverride.pointsIntervalRelations(),
modelExportOverride.pointsIntervalUnitsRelations(),
lineStyle.curveConnectAs(),
transformation,
points);
if (curve->curveStyle().lineStyle().curveConnectAs() == CONNECT_AS_RELATION_SMOOTH) {
loadXThetaYRadiusValuesForCurveInterpolatedSmooth (document.modelCoords(),
document.modelGeneral(),
modelMainWindow,
points,
ordinals,
xThetaYRadiusValues [colXTheta],
xThetaYRadiusValues [colYRadius],
transformation);
} else {
loadXThetaYRadiusValuesForCurveInterpolatedStraight (document.modelCoords(),
document.modelGeneral(),
modelMainWindow,
points,
ordinals,
xThetaYRadiusValues [colXTheta],
xThetaYRadiusValues [colYRadius],
transformation);
}
}
}
}
DocumentModelExportFormat::DocumentModelExportFormat(const DocumentModelExportFormat &other) :
m_curveNamesNotExported (other.curveNamesNotExported()),
m_pointsSelectionFunctions (other.pointsSelectionFunctions()),
m_pointsIntervalFunctions (other.pointsIntervalFunctions()),
m_pointsIntervalUnitsFunctions (other.pointsIntervalUnitsFunctions()),
m_pointsSelectionRelations (other.pointsSelectionRelations()),
m_pointsIntervalRelations (other.pointsIntervalRelations()),
m_pointsIntervalUnitsRelations (other.pointsIntervalUnitsRelations()),
m_layoutFunctions (other.layoutFunctions()),
m_delimiter (other.delimiter()),
m_header (other.header()),
m_xLabel (other.xLabel ())
{
}
