void CRandomFieldGridMap3D::writeToStream(mrpt::utils::CStream &out, int *version) const
{
if (version)
*version = 0;
else
{
dyngridcommon_writeToStream(out);
// To assure compatibility: The size of each cell:
uint32_t n = static_cast<uint32_t>(sizeof(TRandomFieldVoxel));
out << n;
// Save the map contents:
n = static_cast<uint32_t>(m_map.size());
out << n;
// Save the "m_map": This requires special handling for big endian systems:
#if MRPT_IS_BIG_ENDIAN
for (uint32_t i = 0; i<n; i++)
{
out << m_map[i].mean_value << m_map[i].stddev_value;
}
#else
// Little endian: just write all at once:
out.WriteBuffer(&m_map[0], sizeof(m_map[0])*m_map.size());
#endif
out << insertionOptions.GMRF_lambdaPrior
<< insertionOptions.GMRF_skip_variance;
}
}
/*---------------------------------------------------------------
Implements the writing to a CStream capability of CSerializable objects
---------------------------------------------------------------*/
void CWirelessPowerGridMap2D::writeToStream(mrpt::utils::CStream &out, int *version) const
{
if (version)
*version = 5;
else
{
dyngridcommon_writeToStream(out);
// To ensure compatibility: The size of each cell:
uint32_t n = static_cast<uint32_t>(sizeof( TRandomFieldCell ));
out << n;
// Save the map contents:
n = static_cast<uint32_t>(m_map.size());
out << n;
// Save the "m_map": This requires special handling for big endian systems:
#if MRPT_IS_BIG_ENDIAN
for (uint32_t i=0;i<n;i++)
{
out << m_map[i].kf_mean << m_map[i].dm_mean << m_map[i].dmv_var_mean;
}
#else
// Little endian: just write all at once:
out.WriteBuffer( &m_map[0], sizeof(m_map[0])*m_map.size() ); // TODO: Do this endianness safe!!
#endif
// Version 1: Save the insertion options:
out << uint8_t(m_mapType)
<< m_cov
<< m_stackedCov;
out << insertionOptions.sigma
<< insertionOptions.cutoffRadius
<< insertionOptions.R_min
<< insertionOptions.R_max
<< insertionOptions.KF_covSigma
<< insertionOptions.KF_initialCellStd
<< insertionOptions.KF_observationModelNoise
<< insertionOptions.KF_defaultCellMeanValue
<< insertionOptions.KF_W_size;
// New in v3:
out << m_average_normreadings_mean << m_average_normreadings_var << uint64_t(m_average_normreadings_count);
out << genericMapParams; // v4
}
}
/*---------------------------------------------------------------
writeToStream
---------------------------------------------------------------*/
void CMemoryChunk::writeToStream(mrpt::utils::CStream &out, int *out_Version) const
{
if (out_Version)
*out_Version = 0;
else
{
out << static_cast<uint64_t>(m_bytesWritten);
if (m_bytesWritten)
{
ASSERT_(m_memory.get())
out.WriteBuffer(m_memory.get(),m_bytesWritten);
}
}
}
void CRenderizable::writeToStreamRender(mrpt::utils::CStream &out) const
{
// MRPT 0.9.5 svn 2774 (Dec 14th 2011):
// Added support of versioning at this level of serialization too.
// Should have been done from the beginning, terrible mistake on my part.
// Now, the only solution is something as ugly as this:
//
// For reference: In the past this started as:
// out << m_name << (float)(m_color.R) << (float)(m_color.G) << (float)(m_color.B) << (float)(m_color.A);
// ...
const uint8_t serialization_version = 0; // can't be >31 (but it would be mad geting to that situation!)
const bool all_scales_equal = (m_scale_x==m_scale_y && m_scale_z==m_scale_x);
const bool all_scales_unity = (all_scales_equal && m_scale_x==1.0f);
const uint8_t magic_signature[2] = {
0xFF,
// bit7: fixed to 1 to mark this new header format
// bit6: whether the 3 scale{x,y,z} are equal to 1.0
// bit5: whether the 3 scale{x,y,z} are equal to each other
static_cast<uint8_t>( serialization_version | (all_scales_unity ? 0xC0 : (all_scales_equal ? 0xA0 : 0x80) ) )
};
out << magic_signature[0] << magic_signature[1];
// "m_name"
const uint16_t nameLen = static_cast<uint16_t>(m_name.size());
out << nameLen;
if (nameLen) out.WriteBuffer(m_name.c_str(),m_name.size());
// Color, as u8:
out << m_color.R << m_color.G << m_color.B << m_color.A;
// the rest of fields:
out << (float)m_pose.x() << (float)m_pose.y() << (float)m_pose.z()
<< (float)m_pose.yaw() << (float)m_pose.pitch() << (float)m_pose.roll();
if (!all_scales_unity)
{
if (all_scales_equal)
out << m_scale_x;
else out << m_scale_x << m_scale_y << m_scale_z;
}
out << m_show_name
<< m_visible;
}
/*---------------------------------------------------------------
writeToStream
---------------------------------------------------------------*/
void CMatrixB::writeToStream(mrpt::utils::CStream &out, int *out_Version) const
{
if (out_Version)
*out_Version = 0;
else
{
out << (uint32_t)sizeof(m_Val[0][0]);
// First, write the number of rows and columns:
out << (uint32_t)m_Rows << (uint32_t)m_Cols;
if (m_Rows>0 && m_Cols>0)
for (unsigned int i=0;i<m_Rows;i++)
out.WriteBuffer(m_Val[i],sizeof(m_Val[0][0])*m_Cols);
}
}